@link-assistant/agent 0.0.9 → 0.0.12

package/src/tool/registry.ts

@@ -1,42 +1,42 @@
-import { BashTool } from "./bash"
-import { EditTool } from "./edit"
-import { GlobTool } from "./glob"
-import { GrepTool } from "./grep"
-import { ListTool } from "./ls"
-import { BatchTool } from "./batch"
-import { ReadTool } from "./read"
-import { TaskTool } from "./task"
-import { TodoWriteTool, TodoReadTool } from "./todo"
-import { WebFetchTool } from "./webfetch"
-import { WriteTool } from "./write"
-import { InvalidTool } from "./invalid"
-import type { Agent } from "../agent/agent"
-import { Tool } from "./tool"
-import { Instance } from "../project/instance"
-import { Config } from "../config/config"
-import { WebSearchTool } from "./websearch"
-import { CodeSearchTool } from "./codesearch"
-import { Flag } from "../flag/flag"
+import { BashTool } from './bash';
+import { EditTool } from './edit';
+import { GlobTool } from './glob';
+import { GrepTool } from './grep';
+import { ListTool } from './ls';
+import { BatchTool } from './batch';
+import { ReadTool } from './read';
+import { TaskTool } from './task';
+import { TodoWriteTool, TodoReadTool } from './todo';
+import { WebFetchTool } from './webfetch';
+import { WriteTool } from './write';
+import { InvalidTool } from './invalid';
+import type { Agent } from '../agent/agent';
+import { Tool } from './tool';
+import { Instance } from '../project/instance';
+import { Config } from '../config/config';
+import { WebSearchTool } from './websearch';
+import { CodeSearchTool } from './codesearch';
+import { Flag } from '../flag/flag';
 
 export namespace ToolRegistry {
   export const state = Instance.state(async () => {
-    const custom = [] as Tool.Info[]
-    return { custom }
-  })
+    const custom = [] as Tool.Info[];
+    return { custom };
+  });
 
   export async function register(tool: Tool.Info) {
-    const { custom } = await state()
-    const idx = custom.findIndex((t) => t.id === tool.id)
+    const { custom } = await state();
+    const idx = custom.findIndex((t) => t.id === tool.id);
     if (idx >= 0) {
-      custom.splice(idx, 1, tool)
-      return
+      custom.splice(idx, 1, tool);
+      return;
     }
-    custom.push(tool)
+    custom.push(tool);
   }
 
   async function all(): Promise<Tool.Info[]> {
-    const custom = await state().then((x) => x.custom)
-    const config = await Config.get()
+    const custom = await state().then((x) => x.custom);
+    const config = await Config.get();
 
     return [
       InvalidTool,
@@ -55,33 +55,33 @@ export namespace ToolRegistry {
       TodoWriteTool,
       TodoReadTool,
       ...custom,
-    ]
+    ];
   }
 
   export async function ids() {
-    return all().then((x) => x.map((t) => t.id))
+    return all().then((x) => x.map((t) => t.id));
   }
 
   export async function tools(_providerID: string, _modelID: string) {
-    const tools = await all()
+    const tools = await all();
     const result = await Promise.all(
       tools.map(async (t) => ({
         id: t.id,
         ...(await t.init()),
-      })),
-    )
-    return result
+      }))
+    );
+    return result;
   }
 
   export async function enabled(
     _providerID: string,
     _modelID: string,
-    agent: Agent.Info,
+    agent: Agent.Info
   ): Promise<Record<string, boolean>> {
-    const result: Record<string, boolean> = {}
+    const result: Record<string, boolean> = {};
 
     // Permission system removed - all tools enabled by default
 
-    return result
+    return result;
   }
 }

package/src/tool/task.ts

@@ -1,54 +1,72 @@
-import { Tool } from "./tool"
-import DESCRIPTION from "./task.txt"
-import z from "zod"
-import { Session } from "../session"
-import { Bus } from "../bus"
-import { MessageV2 } from "../session/message-v2"
-import { Identifier } from "../id/id"
-import { Agent } from "../agent/agent"
-import { SessionPrompt } from "../session/prompt"
-import { iife } from "../util/iife"
-import { defer } from "../util/defer"
+import { Tool } from './tool';
+import DESCRIPTION from './task.txt';
+import z from 'zod';
+import { Session } from '../session';
+import { Bus } from '../bus';
+import { MessageV2 } from '../session/message-v2';
+import { Identifier } from '../id/id';
+import { Agent } from '../agent/agent';
+import { SessionPrompt } from '../session/prompt';
+import { iife } from '../util/iife';
+import { defer } from '../util/defer';
 
-export const TaskTool = Tool.define("task", async () => {
-  const agents = await Agent.list().then((x) => x.filter((a) => a.mode !== "primary"))
+export const TaskTool = Tool.define('task', async () => {
+  const agents = await Agent.list().then((x) =>
+    x.filter((a) => a.mode !== 'primary')
+  );
   const description = DESCRIPTION.replace(
-    "{agents}",
+    '{agents}',
     agents
-      .map((a) => `- ${a.name}: ${a.description ?? "This subagent should only be called manually by the user."}`)
-      .join("\n"),
-  )
+      .map(
+        (a) =>
+          `- ${a.name}: ${a.description ?? 'This subagent should only be called manually by the user.'}`
+      )
+      .join('\n')
+  );
   return {
     description,
     parameters: z.object({
-      description: z.string().describe("A short (3-5 words) description of the task"),
-      prompt: z.string().describe("The task for the agent to perform"),
-      subagent_type: z.string().describe("The type of specialized agent to use for this task"),
-      session_id: z.string().describe("Existing Task session to continue").optional(),
+      description: z
+        .string()
+        .describe('A short (3-5 words) description of the task'),
+      prompt: z.string().describe('The task for the agent to perform'),
+      subagent_type: z
+        .string()
+        .describe('The type of specialized agent to use for this task'),
+      session_id: z
+        .string()
+        .describe('Existing Task session to continue')
+        .optional(),
     }),
     async execute(params, ctx) {
-      const agent = await Agent.get(params.subagent_type)
-      if (!agent) throw new Error(`Unknown agent type: ${params.subagent_type} is not a valid agent type`)
+      const agent = await Agent.get(params.subagent_type);
+      if (!agent)
+        throw new Error(
+          `Unknown agent type: ${params.subagent_type} is not a valid agent type`
+        );
       const session = await iife(async () => {
         if (params.session_id) {
-          const found = await Session.get(params.session_id).catch(() => {})
-          if (found) return found
+          const found = await Session.get(params.session_id).catch(() => {});
+          if (found) return found;
         }
 
         return await Session.create({
           parentID: ctx.sessionID,
           title: params.description + ` (@${agent.name} subagent)`,
-        })
-      })
+        });
+      });
       // Try to get parent message for model info, but use defaults if not available
-      let parentModel: { modelID: string; providerID: string } | undefined
+      let parentModel: { modelID: string; providerID: string } | undefined;
       try {
-        const msg = await MessageV2.get({ sessionID: ctx.sessionID, messageID: ctx.messageID })
-        if (msg.info.role === "assistant") {
+        const msg = await MessageV2.get({
+          sessionID: ctx.sessionID,
+          messageID: ctx.messageID,
+        });
+        if (msg.info.role === 'assistant') {
           parentModel = {
             modelID: msg.info.modelID,
             providerID: msg.info.providerID,
-          }
+          };
         }
       } catch (e) {
         // Parent message not in storage, will use agent model or default
@@ -59,35 +77,38 @@ export const TaskTool = Tool.define("task", async () => {
         metadata: {
           sessionId: session.id,
         },
-      })
+      });
 
-      const messageID = Identifier.ascending("message")
-      const parts: Record<string, MessageV2.ToolPart> = {}
+      const messageID = Identifier.ascending('message');
+      const parts: Record<string, MessageV2.ToolPart> = {};
       const unsub = Bus.subscribe(MessageV2.Event.PartUpdated, async (evt) => {
-        if (evt.properties.part.sessionID !== session.id) return
-        if (evt.properties.part.messageID === messageID) return
-        if (evt.properties.part.type !== "tool") return
-        parts[evt.properties.part.id] = evt.properties.part
+        if (evt.properties.part.sessionID !== session.id) return;
+        if (evt.properties.part.messageID === messageID) return;
+        if (evt.properties.part.type !== 'tool') return;
+        parts[evt.properties.part.id] = evt.properties.part;
         ctx.metadata({
           title: params.description,
           metadata: {
-            summary: Object.values(parts).sort((a, b) => a.id?.localeCompare(b.id)),
+            summary: Object.values(parts).sort((a, b) =>
+              a.id?.localeCompare(b.id)
+            ),
             sessionId: session.id,
           },
-        })
-      })
+        });
+      });
 
-      const model = agent.model ?? parentModel ?? {
-        modelID: "grok-code",
-        providerID: "opencode",
-      }
+      const model = agent.model ??
+        parentModel ?? {
+          modelID: 'grok-code',
+          providerID: 'opencode',
+        };
 
       function cancel() {
-        SessionPrompt.cancel(session.id)
+        SessionPrompt.cancel(session.id);
       }
-      ctx.abort.addEventListener("abort", cancel)
-      using _ = defer(() => ctx.abort.removeEventListener("abort", cancel))
-      const promptParts = await SessionPrompt.resolvePromptParts(params.prompt)
+      ctx.abort.addEventListener('abort', cancel);
+      using _ = defer(() => ctx.abort.removeEventListener('abort', cancel));
+      const promptParts = await SessionPrompt.resolvePromptParts(params.prompt);
       const result = await SessionPrompt.prompt({
         messageID,
         sessionID: session.id,
@@ -103,15 +124,27 @@ export const TaskTool = Tool.define("task", async () => {
           ...agent.tools,
         },
         parts: promptParts,
-      })
-      unsub()
-      let all
-      all = await Session.messages({ sessionID: session.id })
-      all = all.filter((x) => x.info.role === "assistant")
-      all = all.flatMap((msg) => msg.parts.filter((x: any) => x.type === "tool") as MessageV2.ToolPart[])
-      const text = result.parts.findLast((x) => x.type === "text")?.text ?? ""
+      });
+      unsub();
+      let all;
+      all = await Session.messages({ sessionID: session.id });
+      all = all.filter((x) => x.info.role === 'assistant');
+      all = all.flatMap(
+        (msg) =>
+          msg.parts.filter(
+            (x: any) => x.type === 'tool'
+          ) as MessageV2.ToolPart[]
+      );
+      const text = result.parts.findLast((x) => x.type === 'text')?.text ?? '';
 
-      const output = text + "\n\n" + ["<task_metadata>", `session_id: ${session.id}`, "</task_metadata>"].join("\n")
+      const output =
+        text +
+        '\n\n' +
+        [
+          '<task_metadata>',
+          `session_id: ${session.id}`,
+          '</task_metadata>',
+        ].join('\n');
 
       return {
         title: params.description,
@@ -120,7 +153,7 @@ export const TaskTool = Tool.define("task", async () => {
           sessionId: session.id,
         },
         output,
-      }
+      };
     },
-  }
-})
+  };
+});

package/src/tool/todo.ts

@@ -1,39 +1,39 @@
-import z from "zod"
-import { Tool } from "./tool"
-import DESCRIPTION_WRITE from "./todowrite.txt"
-import { Todo } from "../session/todo"
+import z from 'zod';
+import { Tool } from './tool';
+import DESCRIPTION_WRITE from './todowrite.txt';
+import { Todo } from '../session/todo';
 
-export const TodoWriteTool = Tool.define("todowrite", {
+export const TodoWriteTool = Tool.define('todowrite', {
   description: DESCRIPTION_WRITE,
   parameters: z.object({
-    todos: z.array(z.object(Todo.Info.shape)).describe("The updated todo list"),
+    todos: z.array(z.object(Todo.Info.shape)).describe('The updated todo list'),
   }),
   async execute(params, opts) {
     await Todo.update({
       sessionID: opts.sessionID,
       todos: params.todos,
-    })
+    });
     return {
-      title: `${params.todos.filter((x) => x.status !== "completed").length} todos`,
+      title: `${params.todos.filter((x) => x.status !== 'completed').length} todos`,
       output: JSON.stringify(params.todos, null, 2),
       metadata: {
         todos: params.todos,
       },
-    }
+    };
   },
-})
+});
 
-export const TodoReadTool = Tool.define("todoread", {
-  description: "Use this tool to read your todo list",
+export const TodoReadTool = Tool.define('todoread', {
+  description: 'Use this tool to read your todo list',
   parameters: z.object({}),
   async execute(_params, opts) {
-    const todos = await Todo.get(opts.sessionID)
+    const todos = await Todo.get(opts.sessionID);
     return {
-      title: `${todos.filter((x) => x.status !== "completed").length} todos`,
+      title: `${todos.filter((x) => x.status !== 'completed').length} todos`,
       metadata: {
         todos,
       },
       output: JSON.stringify(todos, null, 2),
-    }
+    };
   },
-})
+});

package/src/tool/tool.ts

@@ -1,66 +1,75 @@
-import z from "zod"
-import type { MessageV2 } from "../session/message-v2"
+import z from 'zod';
+import type { MessageV2 } from '../session/message-v2';
 
 export namespace Tool {
   interface Metadata {
-    [key: string]: any
+    [key: string]: any;
   }
 
   export type Context<M extends Metadata = Metadata> = {
-    sessionID: string
-    messageID: string
-    agent: string
-    abort: AbortSignal
-    callID?: string
-    extra?: { [key: string]: any }
-    metadata(input: { title?: string; metadata?: M }): void
-  }
-  export interface Info<Parameters extends z.ZodType = z.ZodType, M extends Metadata = Metadata> {
-    id: string
+    sessionID: string;
+    messageID: string;
+    agent: string;
+    abort: AbortSignal;
+    callID?: string;
+    extra?: { [key: string]: any };
+    metadata(input: { title?: string; metadata?: M }): void;
+  };
+  export interface Info<
+    Parameters extends z.ZodType = z.ZodType,
+    M extends Metadata = Metadata,
+  > {
+    id: string;
     init: () => Promise<{
-      description: string
-      parameters: Parameters
+      description: string;
+      parameters: Parameters;
       execute(
         args: z.infer<Parameters>,
-        ctx: Context,
+        ctx: Context
       ): Promise<{
-        title: string
-        metadata: M
-        output: string
-        attachments?: MessageV2.FilePart[]
-      }>
-      formatValidationError?(error: z.ZodError): string
-    }>
+        title: string;
+        metadata: M;
+        output: string;
+        attachments?: MessageV2.FilePart[];
+      }>;
+      formatValidationError?(error: z.ZodError): string;
+    }>;
   }
 
-  export type InferParameters<T extends Info> = T extends Info<infer P> ? z.infer<P> : never
-  export type InferMetadata<T extends Info> = T extends Info<any, infer M> ? M : never
+  export type InferParameters<T extends Info> =
+    T extends Info<infer P> ? z.infer<P> : never;
+  export type InferMetadata<T extends Info> =
+    T extends Info<any, infer M> ? M : never;
 
   export function define<Parameters extends z.ZodType, Result extends Metadata>(
     id: string,
-    init: Info<Parameters, Result>["init"] | Awaited<ReturnType<Info<Parameters, Result>["init"]>>,
+    init:
+      | Info<Parameters, Result>['init']
+      | Awaited<ReturnType<Info<Parameters, Result>['init']>>
   ): Info<Parameters, Result> {
     return {
       id,
       init: async () => {
-        const toolInfo = init instanceof Function ? await init() : init
-        const execute = toolInfo.execute
+        const toolInfo = init instanceof Function ? await init() : init;
+        const execute = toolInfo.execute;
         toolInfo.execute = (args, ctx) => {
           try {
-            toolInfo.parameters.parse(args)
+            toolInfo.parameters.parse(args);
           } catch (error) {
             if (error instanceof z.ZodError && toolInfo.formatValidationError) {
-              throw new Error(toolInfo.formatValidationError(error), { cause: error })
+              throw new Error(toolInfo.formatValidationError(error), {
+                cause: error,
+              });
             }
             throw new Error(
               `The ${id} tool was called with invalid arguments: ${error}.\nPlease rewrite the input so it satisfies the expected schema.`,
-              { cause: error },
-            )
+              { cause: error }
+            );
           }
-          return execute(args, ctx)
-        }
-        return toolInfo
+          return execute(args, ctx);
+        };
+        return toolInfo;
       },
-    }
+    };
   }
 }