@link-assistant/agent 0.0.9 → 0.0.12

package/src/server/server.ts

@@ -1,23 +1,23 @@
-import { Log } from "../util/log"
-import { describeRoute, validator, resolver } from "hono-openapi"
-import { Hono } from "hono"
-import { cors } from "hono/cors"
-import { stream } from "hono/streaming"
-import { Session } from "../session"
-import z from "zod"
-import { NamedError } from "../util/error"
-import { MessageV2 } from "../session/message-v2"
-import { Instance } from "../project/instance"
-import { SessionPrompt } from "../session/prompt"
-import { Storage } from "../storage/storage"
-import type { ContentfulStatusCode } from "hono/utils/http-status"
-import { lazy } from "../util/lazy"
+import { Log } from '../util/log';
+import { describeRoute, validator, resolver } from 'hono-openapi';
+import { Hono } from 'hono';
+import { cors } from 'hono/cors';
+import { stream } from 'hono/streaming';
+import { Session } from '../session';
+import z from 'zod';
+import { NamedError } from '../util/error';
+import { MessageV2 } from '../session/message-v2';
+import { Instance } from '../project/instance';
+import { SessionPrompt } from '../session/prompt';
+import { Storage } from '../storage/storage';
+import type { ContentfulStatusCode } from 'hono/utils/http-status';
+import { lazy } from '../util/lazy';
 
 const ERRORS = {
   400: {
-    description: "Bad request",
+    description: 'Bad request',
     content: {
-      "application/json": {
+      'application/json': {
         schema: resolver(
           z
             .object({
@@ -26,98 +26,104 @@ const ERRORS = {
               success: z.literal(false),
             })
             .meta({
-              ref: "BadRequestError",
-            }),
+              ref: 'BadRequestError',
+            })
         ),
       },
     },
   },
   404: {
-    description: "Not found",
+    description: 'Not found',
     content: {
-      "application/json": {
+      'application/json': {
         schema: resolver(Storage.NotFoundError.Schema),
       },
     },
   },
-} as const
+} as const;
 
 function errors(...codes: number[]) {
-  return Object.fromEntries(codes.map((code) => [code, ERRORS[code as keyof typeof ERRORS]]))
+  return Object.fromEntries(
+    codes.map((code) => [code, ERRORS[code as keyof typeof ERRORS]])
+  );
 }
 
 export namespace Server {
-  const log = Log.create({ service: "server" })
+  const log = Log.create({ service: 'server' });
 
-  const app = new Hono()
+  const app = new Hono();
   export const App = lazy(() =>
     app
       .onError((err, c) => {
-        log.error("failed", {
+        log.error('failed', {
           error: err,
-        })
+        });
         if (err instanceof NamedError) {
-          let status: ContentfulStatusCode
-          if (err instanceof Storage.NotFoundError) status = 404
-          else status = 500
-          return c.json(err.toObject(), { status })
+          let status: ContentfulStatusCode;
+          if (err instanceof Storage.NotFoundError) status = 404;
+          else status = 500;
+          return c.json(err.toObject(), { status });
         }
-        const message = err instanceof Error && err.stack ? err.stack : err.toString()
+        const message =
+          err instanceof Error && err.stack ? err.stack : err.toString();
         return c.json(new NamedError.Unknown({ message }).toObject(), {
           status: 500,
-        })
+        });
       })
       .use(async (c, next) => {
-        log.info("request", {
+        log.info('request', {
           method: c.req.method,
           path: c.req.path,
-        })
-        const timer = log.time("request", {
+        });
+        const timer = log.time('request', {
           method: c.req.method,
           path: c.req.path,
-        })
-        await next()
-        timer.stop()
+        });
+        await next();
+        timer.stop();
       })
       .use(cors())
-      .get("/health", (c) => {
-        return c.json({ status: "ok" })
+      .get('/health', (c) => {
+        return c.json({ status: 'ok' });
       })
       .post(
-        "/session",
+        '/session',
         describeRoute({
-          description: "Create a new session",
-          operationId: "session.create",
+          description: 'Create a new session',
+          operationId: 'session.create',
           responses: {
             200: {
-              description: "Created session",
+              description: 'Created session',
               content: {
-                "application/json": {
+                'application/json': {
                   schema: resolver(Session.Info),
                 },
               },
             },
           },
         }),
-        validator("json", z.object({ title: z.string().optional() }).optional()),
+        validator(
+          'json',
+          z.object({ title: z.string().optional() }).optional()
+        ),
         async (c) => {
-          const body = c.req.valid("json") || {}
+          const body = c.req.valid('json') || {};
           const session = await Session.create({
             title: body.title,
-          })
-          return c.json(session)
-        },
+          });
+          return c.json(session);
+        }
       )
       .get(
-        "/session",
+        '/session',
         describeRoute({
-          description: "List all sessions",
-          operationId: "session.list",
+          description: 'List all sessions',
+          operationId: 'session.list',
           responses: {
             200: {
-              description: "List of sessions",
+              description: 'List of sessions',
               content: {
-                "application/json": {
+                'application/json': {
                   schema: resolver(Session.Info.array()),
                 },
               },
@@ -125,20 +131,20 @@ export namespace Server {
           },
         }),
         async (c) => {
-          const sessions = await Session.list()
-          return c.json(sessions)
-        },
+          const sessions = await Session.list();
+          return c.json(sessions);
+        }
       )
       .get(
-        "/session/:id",
+        '/session/:id',
         describeRoute({
-          description: "Get a session",
-          operationId: "session.get",
+          description: 'Get a session',
+          operationId: 'session.get',
           responses: {
             200: {
-              description: "Session info",
+              description: 'Session info',
               content: {
-                "application/json": {
+                'application/json': {
                   schema: resolver(Session.Info),
                 },
               },
@@ -147,31 +153,31 @@ export namespace Server {
           },
         }),
         validator(
-          "param",
+          'param',
           z.object({
             id: z.string(),
-          }),
+          })
         ),
         async (c) => {
-          const session = await Session.get(c.req.valid("param").id)
-          return c.json(session)
-        },
+          const session = await Session.get(c.req.valid('param').id);
+          return c.json(session);
+        }
       )
       .post(
-        "/session/:id/message",
+        '/session/:id/message',
         describeRoute({
-          description: "Create and send a new message to a session",
-          operationId: "session.prompt",
+          description: 'Create and send a new message to a session',
+          operationId: 'session.prompt',
           responses: {
             200: {
-              description: "Created message",
+              description: 'Created message',
               content: {
-                "application/json": {
+                'application/json': {
                   schema: resolver(
                     z.object({
                       info: MessageV2.Assistant,
                       parts: MessageV2.Part.array(),
-                    }),
+                    })
                   ),
                 },
               },
@@ -180,33 +186,33 @@ export namespace Server {
           },
         }),
         validator(
-          "param",
+          'param',
           z.object({
-            id: z.string().meta({ description: "Session ID" }),
-          }),
+            id: z.string().meta({ description: 'Session ID' }),
+          })
         ),
-        validator("json", SessionPrompt.PromptInput.omit({ sessionID: true })),
+        validator('json', SessionPrompt.PromptInput.omit({ sessionID: true })),
         async (c) => {
-          c.status(200)
-          c.header("Content-Type", "application/json")
+          c.status(200);
+          c.header('Content-Type', 'application/json');
           return stream(c, async (stream) => {
-            const sessionID = c.req.valid("param").id
-            const body = c.req.valid("json")
-            const msg = await SessionPrompt.prompt({ ...body, sessionID })
-            stream.write(JSON.stringify(msg))
-          })
-        },
+            const sessionID = c.req.valid('param').id;
+            const body = c.req.valid('json');
+            const msg = await SessionPrompt.prompt({ ...body, sessionID });
+            stream.write(JSON.stringify(msg));
+          });
+        }
       )
       .get(
-        "/session/:id/message",
+        '/session/:id/message',
         describeRoute({
-          description: "List messages for a session",
-          operationId: "session.messages",
+          description: 'List messages for a session',
+          operationId: 'session.messages',
           responses: {
             200: {
-              description: "List of messages",
+              description: 'List of messages',
               content: {
-                "application/json": {
+                'application/json': {
                   schema: resolver(MessageV2.WithParts.array()),
                 },
               },
@@ -215,27 +221,27 @@ export namespace Server {
           },
         }),
         validator(
-          "param",
+          'param',
           z.object({
-            id: z.string().meta({ description: "Session ID" }),
-          }),
+            id: z.string().meta({ description: 'Session ID' }),
+          })
         ),
         validator(
-          "query",
+          'query',
           z.object({
             limit: z.coerce.number().optional(),
-          }),
+          })
         ),
         async (c) => {
-          const query = c.req.valid("query")
+          const query = c.req.valid('query');
           const messages = await Session.messages({
-            sessionID: c.req.valid("param").id,
+            sessionID: c.req.valid('param').id,
             limit: query.limit,
-          })
-          return c.json(messages)
-        },
-      ),
-  )
+          });
+          return c.json(messages);
+        }
+      )
+  );
 
   export function listen(opts: { port: number; hostname: string }) {
     const server = Bun.serve({
@@ -243,7 +249,7 @@ export namespace Server {
       hostname: opts.hostname,
       idleTimeout: 0,
       fetch: App().fetch,
-    })
-    return server
+    });
+    return server;
   }
 }

package/src/session/agent.js

@@ -2,27 +2,27 @@
 // Permalink: https://github.com/sst/opencode/blob/main/packages/opencode/src/session/index.ts
 // Permalink: https://github.com/sst/opencode/blob/main/packages/opencode/src/provider/provider.ts
 
-import { ToolRegistry } from '../tool/registry.ts'
+import { ToolRegistry } from '../tool/registry.ts';
 
 export class Agent {
   constructor() {
     // Generate IDs in the same format as opencode
-    const randomId = Math.random().toString(36).substring(2, 15)
-    this.sessionID = `ses_${Date.now().toString(36)}${randomId}`
-    this.messageID = `msg_${Date.now().toString(36)}${randomId}`
-    this.partCounter = 0
+    const randomId = Math.random().toString(36).substring(2, 15);
+    this.sessionID = `ses_${Date.now().toString(36)}${randomId}`;
+    this.messageID = `msg_${Date.now().toString(36)}${randomId}`;
+    this.partCounter = 0;
   }
 
   generatePartId() {
-    return `prt_${Date.now().toString(36)}${Math.random().toString(36).substring(2, 15)}`
+    return `prt_${Date.now().toString(36)}${Math.random().toString(36).substring(2, 15)}`;
   }
 
   async process(request) {
-    const message = request.message || "hi"
-    const sessionID = this.sessionID
+    const message = request.message || 'hi';
+    const sessionID = this.sessionID;
 
     // Generate snapshot hash (mock)
-    const snapshot = Math.random().toString(16).substring(2, 42)
+    const snapshot = Math.random().toString(16).substring(2, 42);
 
     // Emit step_start like opencode
     this.emitEvent('step_start', {
@@ -31,21 +31,21 @@ export class Agent {
         sessionID,
         messageID: this.messageID,
         type: 'step-start',
-        snapshot
-      }
-    })
+        snapshot,
+      },
+    });
 
     // Check if this is a tool request
     if (request.tools && request.tools.length > 0) {
       // Handle tool execution
-      const toolsList = await ToolRegistry.tools('', '')
-      const toolsMap = Object.fromEntries(toolsList.map(t => [t.id, t]))
+      const toolsList = await ToolRegistry.tools('', '');
+      const toolsMap = Object.fromEntries(toolsList.map((t) => [t.id, t]));
       for (const tool of request.tools) {
-        const toolFn = toolsMap[tool.name]
+        const toolFn = toolsMap[tool.name];
         if (toolFn) {
           try {
-            const startTime = Date.now()
-            const callID = `call_${Math.floor(Math.random() * 100000000)}`
+            const startTime = Date.now();
+            const callID = `call_${Math.floor(Math.random() * 100000000)}`;
 
             // Create OpenCode-compatible context
             const ctx = {
@@ -54,13 +54,13 @@ export class Agent {
               agent: 'default',
               callID,
               abort: new AbortController().signal,
-              metadata: (data) => {
+              metadata: (_data) => {
                 // Handle metadata updates during execution
-              }
-            }
+              },
+            };
 
-            const result = await toolFn.execute(tool.params, ctx)
-            const endTime = Date.now()
+            const result = await toolFn.execute(tool.params, ctx);
+            const endTime = Date.now();
 
             // Emit tool_use event
             this.emitEvent('tool_use', {
@@ -75,25 +75,29 @@ export class Agent {
                   status: 'completed',
                   input: tool.params,
                   output: result.output,
-                  title: result.title || `${tool.name} ${JSON.stringify(tool.params)}`,
+                  title:
+                    result.title ||
+                    `${tool.name} ${JSON.stringify(tool.params)}`,
                   metadata: result.metadata || {
                     output: result.output,
                     exit: result.exitCode || 0,
-                    ...(tool.params.description && { description: tool.params.description })
+                    ...(tool.params.description && {
+                      description: tool.params.description,
+                    }),
                   },
                   time: {
                     start: startTime,
-                    end: endTime
-                  }
-                }
-              }
-            })
+                    end: endTime,
+                  },
+                },
+              },
+            });
           } catch (error) {
-            const errorTime = Date.now()
-            const callID = `call_${Math.floor(Math.random() * 100000000)}`
+            const errorTime = Date.now();
+            const callID = `call_${Math.floor(Math.random() * 100000000)}`;
 
             // Log full error to stderr for debugging
-            console.error('Tool execution error:', error)
+            console.error('Tool execution error:', error);
 
             // Emit tool_use event with error
             this.emitEvent('tool_use', {
@@ -110,11 +114,11 @@ export class Agent {
                   error: error.message || String(error),
                   time: {
                     start: errorTime,
-                    end: errorTime
-                  }
-                }
-              }
-            })
+                    end: errorTime,
+                  },
+                },
+              },
+            });
           }
         }
       }
@@ -133,23 +137,23 @@ export class Agent {
             input: 1273,
             output: 2,
             reasoning: 173,
-            cache: { read: 9536, write: 0 }
-          }
-        }
-      })
+            cache: { read: 9536, write: 0 },
+          },
+        },
+      });
 
       return {
         sessionID,
-        timestamp: Date.now()
-      }
+        timestamp: Date.now(),
+      };
     }
 
     // Regular message processing
     // Simulate processing delay
-    await new Promise(resolve => setTimeout(resolve, 100))
+    await new Promise((resolve) => setTimeout(resolve, 100));
 
     // Emit text response like opencode
-    const responseText = message === "hi" ? "Hi!" : `You said: "${message}"`
+    const responseText = message === 'hi' ? 'Hi!' : `You said: "${message}"`;
     this.emitEvent('text', {
       part: {
         id: this.generatePartId(),
@@ -159,10 +163,10 @@ export class Agent {
         text: responseText,
         time: {
           start: Date.now(),
-          end: Date.now()
-        }
-      }
-    })
+          end: Date.now(),
+        },
+      },
+    });
 
     // Emit step_finish with cost and tokens like opencode
     this.emitEvent('step_finish', {
@@ -178,15 +182,15 @@ export class Agent {
           input: 1273,
           output: 2,
           reasoning: 173,
-          cache: { read: 9536, write: 0 }
-        }
-      }
-    })
+          cache: { read: 9536, write: 0 },
+        },
+      },
+    });
 
     return {
       sessionID,
-      timestamp: Date.now()
-    }
+      timestamp: Date.now(),
+    };
   }
 
   emitEvent(type, data) {
@@ -194,11 +198,13 @@ export class Agent {
       type,
       timestamp: Date.now(),
       sessionID: this.sessionID,
-      ...data
-    }
+      ...data,
+    };
     // Pretty-print JSON for human readability, compact for programmatic use
     // Use AGENT_CLI_COMPACT=1 for compact output (tests, automation)
-    const compact = process.env.AGENT_CLI_COMPACT === '1'
-    console.log(compact ? JSON.stringify(event) : JSON.stringify(event, null, 2))
+    const compact = process.env.AGENT_CLI_COMPACT === '1';
+    console.log(
+      compact ? JSON.stringify(event) : JSON.stringify(event, null, 2)
+    );
   }
-}
+}