@strayl/agent 0.1.2 → 0.1.4

package/src/tools/external/web-fetch.ts

@@ -1,57 +0,0 @@
-import { z } from "zod";
-import type { ToolDefinition, ToolContext } from "../../types.js";
-import { proxyFetch } from "./proxy-fetch.js";
-
-export const webFetchTool: ToolDefinition = {
-  name: "web_fetch",
-  description:
-    "Fetch and extract content from a URL using Jina Reader API. " +
-    "Returns the page title and main text content, cleaned of HTML.",
-  parameters: z.object({
-    url: z.string().describe("URL to fetch"),
-    maxLength: z.number().optional().describe("Maximum content length in characters (default: 20000)"),
-  }),
-  execute: async (rawArgs: unknown, ctx: ToolContext): Promise<string> => {
-    const args = rawArgs as { url: string; maxLength?: number };
-    const maxLength = args.maxLength ?? 20000;
-
-    try {
-      const response = await proxyFetch(
-        "jina",
-        `https://r.jina.ai/${args.url}`,
-        "JINA_API_KEY",
-        {
-          method: "GET",
-          headers: { Accept: "application/json" },
-        },
-        ctx.env,
-      );
-
-      if (!response.ok) {
-        return JSON.stringify({
-          success: false,
-          url: args.url,
-          error: `Jina Reader error: ${response.status} ${response.statusText}`,
-        });
-      }
-
-      const data = (await response.json()) as {
-        data?: { title?: string; content?: string };
-        title?: string;
-        content?: string;
-      };
-
-      const title = data.data?.title ?? data.title ?? "";
-      let content = data.data?.content ?? data.content ?? "";
-
-      if (content.length > maxLength) {
-        content = content.slice(0, maxLength) + "\n\n[... content truncated ...]";
-      }
-
-      return JSON.stringify({ success: true, url: args.url, title, content });
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      return JSON.stringify({ success: false, url: args.url, error: `Fetch failed: ${msg}` });
-    }
-  },
-};

package/src/tools/external/web-search.ts

@@ -1,61 +0,0 @@
-import { z } from "zod";
-import type { ToolDefinition, ToolContext } from "../../types.js";
-import { proxyFetch } from "./proxy-fetch.js";
-
-export const webSearchTool: ToolDefinition = {
-  name: "web_search",
-  description:
-    "Search the web for information using Tavily API. " +
-    "Returns relevant results with titles, URLs, and content snippets.",
-  parameters: z.object({
-    query: z.string().describe("Search query"),
-    maxResults: z.number().optional().describe("Maximum number of results (default: 5)"),
-    topic: z.enum(["general", "news"]).optional().describe("Search topic: 'general' or 'news' (default: 'general')"),
-  }),
-  execute: async (rawArgs: unknown, ctx: ToolContext): Promise<string> => {
-    const args = rawArgs as { query: string; maxResults?: number; topic?: string };
-
-    try {
-      const response = await proxyFetch(
-        "tavily",
-        "https://api.tavily.com/search",
-        "TAVILY_API_KEY",
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            query: args.query,
-            max_results: args.maxResults ?? 5,
-            topic: args.topic ?? "general",
-            include_answer: true,
-          }),
-        },
-        ctx.env,
-      );
-
-      if (!response.ok) {
-        return JSON.stringify({ error: `Tavily API error: ${response.status} ${response.statusText}` });
-      }
-
-      const data = (await response.json()) as {
-        query: string;
-        answer?: string;
-        results: Array<{ title: string; url: string; content: string }>;
-      };
-
-      return JSON.stringify({
-        success: true,
-        query: data.query,
-        answer: data.answer,
-        results: data.results.map(r => ({
-          title: r.title,
-          url: r.url,
-          content: r.content?.slice(0, 500),
-        })),
-      });
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      return JSON.stringify({ error: `Web search failed: ${msg}` });
-    }
-  },
-};

package/src/tools/registry.ts

@@ -1,36 +0,0 @@
-import type OpenAI from "openai";
-import type { ToolDefinition } from "../types.js";
-import { zodToJsonSchema } from "./zod-to-json-schema.js";
-
-export class ToolRegistry {
-  private tools = new Map<string, ToolDefinition>();
-
-  register(tool: ToolDefinition): void {
-    this.tools.set(tool.name, tool);
-  }
-
-  get(name: string): ToolDefinition | undefined {
-    return this.tools.get(name);
-  }
-
-  has(name: string): boolean {
-    return this.tools.has(name);
-  }
-
-  names(): string[] {
-    return [...this.tools.keys()];
-  }
-
-  toOpenAITools(blocked?: Set<string>): OpenAI.ChatCompletionTool[] {
-    return [...this.tools.values()]
-      .filter(t => !blocked?.has(t.name))
-      .map(t => ({
-        type: "function" as const,
-        function: {
-          name: t.name,
-          description: t.description,
-          parameters: zodToJsonSchema(t.parameters),
-        },
-      }));
-  }
-}

package/src/tools/zod-to-json-schema.ts

@@ -1,86 +0,0 @@
-import type { z } from "zod";
-
-export function zodToJsonSchema(schema: z.ZodType): Record<string, unknown> {
-  return convertSchema(schema);
-}
-
-function convertSchema(schema: z.ZodType): Record<string, unknown> {
-  const def = (schema as unknown as { _def: Record<string, unknown> })._def;
-  const typeName = def.typeName as string;
-  const description = def.description as string | undefined;
-
-  const base: Record<string, unknown> = {};
-  if (description) base.description = description;
-
-  switch (typeName) {
-    case "ZodString":
-      return { ...base, type: "string" };
-
-    case "ZodNumber":
-      return { ...base, type: "number" };
-
-    case "ZodBoolean":
-      return { ...base, type: "boolean" };
-
-    case "ZodEnum": {
-      const values = (def.values as string[]);
-      return { ...base, type: "string", enum: values };
-    }
-
-    case "ZodArray": {
-      const itemSchema = def.type as z.ZodType;
-      const result: Record<string, unknown> = { ...base, type: "array", items: convertSchema(itemSchema) };
-      if (def.minLength != null) result.minItems = (def.minLength as { value: number }).value;
-      if (def.maxLength != null) result.maxItems = (def.maxLength as { value: number }).value;
-      return result;
-    }
-
-    case "ZodObject": {
-      const shape = (def.shape as () => Record<string, z.ZodType>)();
-      const properties: Record<string, unknown> = {};
-      const required: string[] = [];
-
-      for (const [key, value] of Object.entries(shape)) {
-        const innerDef = (value as unknown as { _def: Record<string, unknown> })._def;
-        if (innerDef.typeName === "ZodOptional") {
-          properties[key] = convertSchema(innerDef.innerType as z.ZodType);
-        } else {
-          properties[key] = convertSchema(value);
-          required.push(key);
-        }
-      }
-
-      const result: Record<string, unknown> = { ...base, type: "object", properties };
-      if (required.length > 0) result.required = required;
-      return result;
-    }
-
-    case "ZodOptional": {
-      return convertSchema(def.innerType as z.ZodType);
-    }
-
-    case "ZodDefault": {
-      const inner = convertSchema(def.innerType as z.ZodType);
-      inner.default = def.defaultValue;
-      return inner;
-    }
-
-    case "ZodNullable": {
-      const inner = convertSchema(def.innerType as z.ZodType);
-      return { ...inner, nullable: true };
-    }
-
-    case "ZodLiteral": {
-      const value = def.value;
-      return { ...base, type: typeof value, const: value };
-    }
-
-    case "ZodUnion": {
-      const options = (def.options as z.ZodType[]).map(convertSchema);
-      return { ...base, oneOf: options };
-    }
-
-    default:
-      return { ...base, type: "string" };
-  }
-}

package/src/types.ts

@@ -1,151 +0,0 @@
-import type { z } from "zod";
-import type OpenAI from "openai";
-import type { Emitter } from "./emitter.js";
-
-// ─── Messages (OpenAI Chat Completions format) ──────────────────────
-
-export type Role = "system" | "user" | "assistant" | "tool";
-
-export interface ContentPart {
-  type: "text" | "image_url";
-  text?: string;
-  image_url?: { url: string };
-}
-
-export interface ToolCallFunction {
-  name: string;
-  arguments: string;
-}
-
-export interface ToolCall {
-  id: string;
-  type: "function";
-  function: ToolCallFunction;
-}
-
-export interface Message {
-  role: Role;
-  content: string | ContentPart[] | null;
-  name?: string;
-  tool_call_id?: string;
-  tool_calls?: ToolCall[];
-}
-
-// ─── Agent Configuration ─────────────────────────────────────────────
-
-export type AgentMode = "normal" | "plan" | "implement";
-
-export interface AgentConfig {
-  model: string;
-  userMessage: string;
-  sessionId: string;
-  workDir: string;
-  env: Record<string, string>;
-  mode?: AgentMode;
-  systemPromptExtra?: string;
-  blockedTools?: string[];
-  maxIterations?: number;
-  summarizationThreshold?: number;
-  preSummarizationRatio?: number;
-  images?: Array<{ base64: string; contentType: string }>;
-  previousSummary?: string;
-  hitlDir?: string;
-  skillsDir?: string;
-  restoreCheckpoint?: CheckpointData;
-}
-
-// ─── Tool System ─────────────────────────────────────────────────────
-
-export interface ToolContext {
-  emitter: Emitter;
-  workDir: string;
-  env: Record<string, string>;
-  sessionId: string;
-  toolCallId: string;
-}
-
-export interface ToolDefinition {
-  name: string;
-  description: string;
-  parameters: z.ZodType;
-  execute: (args: unknown, ctx: ToolContext) => Promise<string>;
-  hitl?: boolean;
-}
-
-// ─── Middleware ───────────────────────────────────────────────────────
-
-export interface Middleware {
-  name: string;
-  beforeModel?: (messages: Message[]) => Message[];
-  filterTools?: (tools: OpenAI.ChatCompletionTool[]) => OpenAI.ChatCompletionTool[];
-  wrapToolCall?: (call: ToolCall, next: () => Promise<string>) => Promise<string>;
-}
-
-// ─── Events (stdout JSON-per-line) ───────────────────────────────────
-
-export type AgentEvent =
-  | { type: "session-start"; model: string; session_id: string }
-  | { type: "session-end"; usage: Usage; exit_reason: "complete" | "max_iterations" | "cancelled" | "error" }
-  | { type: "text-delta"; text: string }
-  | { type: "reasoning-delta"; text: string }
-  | { type: "tool-call-start"; id: string; name: string; args: unknown }
-  | { type: "tool-result"; id: string; name: string; output: unknown; error?: string }
-  | { type: "file-complete"; id: string; path: string; lines: number; bytes: number }
-  | { type: "exec-log"; id: string; data: string }
-  | { type: "hitl-request"; id: string; safe_id: string; tool: string; args: unknown }
-  | { type: "hitl-response"; id: string; decision: string; data: unknown }
-  | { type: "subagent-start"; id: string; name: string; label: string }
-  | { type: "subagent-delta"; id: string; text: string }
-  | { type: "subagent-result"; id: string; output: string }
-  | { type: "todos-update"; todos: TodoItem[] }
-  | { type: "summarizing"; token_count: number; threshold: number }
-  | { type: "summarized"; removed_msgs: number; kept_msgs: number; summary_chars: number }
-  | { type: "usage-update"; input_tokens: number; output_tokens: number; cost?: number; peak_input_tokens: number; context_left_percent: number }
-  | { type: "error"; message: string; recoverable: boolean }
-  | { type: "activity"; activity: ActivityType; message?: string }
-  | { type: "plan-mode-entered"; reason: string }
-  | { type: "plan-confirmed"; plan: string }
-  | { type: "mode-changed"; from: AgentMode; to: AgentMode }
-  | { type: "preview"; port: number; title: string }
-  | { type: "inject-received"; text: string }
-  | { type: "checkpoint-saved"; id: string; iteration: number; checkpoint: CheckpointData }
-  | { type: "checkpoint-restored"; id: string; iteration: number };
-
-export type ActivityType =
-  | "creating-todos"
-  | "updating-todos"
-  | "clearing-todos"
-  | "asking-user"
-  | "planning"
-  | "creating-database"
-  | "running-query"
-  | "running-migration"
-  | "searching-web"
-  | "fetching-page"
-  | "generating-image"
-  | "exploring-codebase"
-  | "reading-file"
-  | "writing-file"
-  | "editing-file"
-  | "running-command"
-  | "delegating-task";
-
-export interface TodoItem {
-  content: string;
-  status: "pending" | "in_progress" | "completed";
-}
-
-export interface Usage {
-  input_tokens: number;
-  output_tokens: number;
-  cost?: number;
-}
-
-export interface CheckpointData {
-  id: string;
-  iteration: number;
-  timestamp: number;
-  messages: Message[];
-  todos: TodoItem[];
-  usage: Usage;
-}