@link-assistant/agent 0.0.8 → 0.0.11

package/src/session/retry.ts

@@ -1,53 +1,56 @@
-import { iife } from "../util/iife"
-import { MessageV2 } from "./message-v2"
+import { iife } from '../util/iife';
+import { MessageV2 } from './message-v2';
 
 export namespace SessionRetry {
-  export const RETRY_INITIAL_DELAY = 2000
-  export const RETRY_BACKOFF_FACTOR = 2
-  export const RETRY_MAX_DELAY_NO_HEADERS = 30_000 // 30 seconds
+  export const RETRY_INITIAL_DELAY = 2000;
+  export const RETRY_BACKOFF_FACTOR = 2;
+  export const RETRY_MAX_DELAY_NO_HEADERS = 30_000; // 30 seconds
 
   export async function sleep(ms: number, signal: AbortSignal): Promise<void> {
     return new Promise((resolve, reject) => {
-      const timeout = setTimeout(resolve, ms)
+      const timeout = setTimeout(resolve, ms);
       signal.addEventListener(
-        "abort",
+        'abort',
         () => {
-          clearTimeout(timeout)
-          reject(new DOMException("Aborted", "AbortError"))
+          clearTimeout(timeout);
+          reject(new DOMException('Aborted', 'AbortError'));
         },
-        { once: true },
-      )
-    })
+        { once: true }
+      );
+    });
   }
 
   export function delay(error: MessageV2.APIError, attempt: number) {
-    const headers = error.data.responseHeaders
+    const headers = error.data.responseHeaders;
     if (headers) {
-      const retryAfterMs = headers["retry-after-ms"]
+      const retryAfterMs = headers['retry-after-ms'];
       if (retryAfterMs) {
-        const parsedMs = Number.parseFloat(retryAfterMs)
+        const parsedMs = Number.parseFloat(retryAfterMs);
         if (!Number.isNaN(parsedMs)) {
-          return parsedMs
+          return parsedMs;
         }
       }
 
-      const retryAfter = headers["retry-after"]
+      const retryAfter = headers['retry-after'];
       if (retryAfter) {
-        const parsedSeconds = Number.parseFloat(retryAfter)
+        const parsedSeconds = Number.parseFloat(retryAfter);
         if (!Number.isNaN(parsedSeconds)) {
           // convert seconds to milliseconds
-          return Math.ceil(parsedSeconds * 1000)
+          return Math.ceil(parsedSeconds * 1000);
         }
         // Try parsing as HTTP date format
-        const parsed = Date.parse(retryAfter) - Date.now()
+        const parsed = Date.parse(retryAfter) - Date.now();
         if (!Number.isNaN(parsed) && parsed > 0) {
-          return Math.ceil(parsed)
+          return Math.ceil(parsed);
         }
       }
 
-      return RETRY_INITIAL_DELAY * Math.pow(RETRY_BACKOFF_FACTOR, attempt - 1)
+      return RETRY_INITIAL_DELAY * Math.pow(RETRY_BACKOFF_FACTOR, attempt - 1);
     }
 
-    return Math.min(RETRY_INITIAL_DELAY * Math.pow(RETRY_BACKOFF_FACTOR, attempt - 1), RETRY_MAX_DELAY_NO_HEADERS)
+    return Math.min(
+      RETRY_INITIAL_DELAY * Math.pow(RETRY_BACKOFF_FACTOR, attempt - 1),
+      RETRY_MAX_DELAY_NO_HEADERS
+    );
   }
 }

package/src/session/revert.ts

@@ -1,108 +1,122 @@
-import z from "zod"
-import { Identifier } from "../id/id"
-import { Snapshot } from "../snapshot"
-import { MessageV2 } from "./message-v2"
-import { Session } from "."
-import { Log } from "../util/log"
-import { splitWhen } from "remeda"
-import { Storage } from "../storage/storage"
-import { Bus } from "../bus"
-import { SessionPrompt } from "./prompt"
+import z from 'zod';
+import { Identifier } from '../id/id';
+import { Snapshot } from '../snapshot';
+import { MessageV2 } from './message-v2';
+import { Session } from '.';
+import { Log } from '../util/log';
+import { splitWhen } from 'remeda';
+import { Storage } from '../storage/storage';
+import { Bus } from '../bus';
+import { SessionPrompt } from './prompt';
 
 export namespace SessionRevert {
-  const log = Log.create({ service: "session.revert" })
+  const log = Log.create({ service: 'session.revert' });
 
   export const RevertInput = z.object({
-    sessionID: Identifier.schema("session"),
-    messageID: Identifier.schema("message"),
-    partID: Identifier.schema("part").optional(),
-  })
-  export type RevertInput = z.infer<typeof RevertInput>
+    sessionID: Identifier.schema('session'),
+    messageID: Identifier.schema('message'),
+    partID: Identifier.schema('part').optional(),
+  });
+  export type RevertInput = z.infer<typeof RevertInput>;
 
   export async function revert(input: RevertInput) {
-    SessionPrompt.assertNotBusy(input.sessionID)
-    const all = await Session.messages({ sessionID: input.sessionID })
-    let lastUser: MessageV2.User | undefined
-    const session = await Session.get(input.sessionID)
+    SessionPrompt.assertNotBusy(input.sessionID);
+    const all = await Session.messages({ sessionID: input.sessionID });
+    let lastUser: MessageV2.User | undefined;
+    const session = await Session.get(input.sessionID);
 
-    let revert: Session.Info["revert"]
-    const patches: Snapshot.Patch[] = []
+    let revert: Session.Info['revert'];
+    const patches: Snapshot.Patch[] = [];
     for (const msg of all) {
-      if (msg.info.role === "user") lastUser = msg.info
-      const remaining = []
+      if (msg.info.role === 'user') lastUser = msg.info;
+      const remaining = [];
       for (const part of msg.parts) {
         if (revert) {
-          if (part.type === "patch") {
-            patches.push(part)
+          if (part.type === 'patch') {
+            patches.push(part);
           }
-          continue
+          continue;
         }
 
         if (!revert) {
-          if ((msg.info.id === input.messageID && !input.partID) || part.id === input.partID) {
+          if (
+            (msg.info.id === input.messageID && !input.partID) ||
+            part.id === input.partID
+          ) {
             // if no useful parts left in message, same as reverting whole message
-            const partID = remaining.some((item) => ["text", "tool"].includes(item.type)) ? input.partID : undefined
+            const partID = remaining.some((item) =>
+              ['text', 'tool'].includes(item.type)
+            )
+              ? input.partID
+              : undefined;
             revert = {
               messageID: !partID && lastUser ? lastUser.id : msg.info.id,
               partID,
-            }
+            };
           }
-          remaining.push(part)
+          remaining.push(part);
         }
       }
     }
 
     if (revert) {
-      const session = await Session.get(input.sessionID)
-      revert.snapshot = session.revert?.snapshot ?? (await Snapshot.track())
-      await Snapshot.revert(patches)
-      if (revert.snapshot) revert.diff = await Snapshot.diff(revert.snapshot)
+      const session = await Session.get(input.sessionID);
+      revert.snapshot = session.revert?.snapshot ?? (await Snapshot.track());
+      await Snapshot.revert(patches);
+      if (revert.snapshot) revert.diff = await Snapshot.diff(revert.snapshot);
       return Session.update(input.sessionID, (draft) => {
-        draft.revert = revert
-      })
+        draft.revert = revert;
+      });
     }
-    return session
+    return session;
   }
 
   export async function unrevert(input: { sessionID: string }) {
-    log.info("unreverting", input)
-    SessionPrompt.assertNotBusy(input.sessionID)
-    const session = await Session.get(input.sessionID)
-    if (!session.revert) return session
-    if (session.revert.snapshot) await Snapshot.restore(session.revert.snapshot)
+    log.info('unreverting', input);
+    SessionPrompt.assertNotBusy(input.sessionID);
+    const session = await Session.get(input.sessionID);
+    if (!session.revert) return session;
+    if (session.revert.snapshot)
+      await Snapshot.restore(session.revert.snapshot);
     const next = await Session.update(input.sessionID, (draft) => {
-      draft.revert = undefined
-    })
-    return next
+      draft.revert = undefined;
+    });
+    return next;
   }
 
   export async function cleanup(session: Session.Info) {
-    if (!session.revert) return
-    const sessionID = session.id
-    let msgs = await Session.messages({ sessionID })
-    const messageID = session.revert.messageID
-    const [preserve, remove] = splitWhen(msgs, (x) => x.info.id === messageID)
-    msgs = preserve
+    if (!session.revert) return;
+    const sessionID = session.id;
+    let msgs = await Session.messages({ sessionID });
+    const messageID = session.revert.messageID;
+    const [preserve, remove] = splitWhen(msgs, (x) => x.info.id === messageID);
+    msgs = preserve;
     for (const msg of remove) {
-      await Storage.remove(["message", sessionID, msg.info.id])
-      await Bus.publish(MessageV2.Event.Removed, { sessionID: sessionID, messageID: msg.info.id })
+      await Storage.remove(['message', sessionID, msg.info.id]);
+      await Bus.publish(MessageV2.Event.Removed, {
+        sessionID: sessionID,
+        messageID: msg.info.id,
+      });
     }
-    const last = preserve.at(-1)
+    const last = preserve.at(-1);
     if (session.revert.partID && last) {
-      const partID = session.revert.partID
-      const [preserveParts, removeParts] = splitWhen(last.parts, (x) => x.id === partID)
-      last.parts = preserveParts
+      const partID = session.revert.partID;
+      const [preserveParts, removeParts] = splitWhen(
+        last.parts,
+        (x) => x.id === partID
+      );
+      last.parts = preserveParts;
       for (const part of removeParts) {
-        await Storage.remove(["part", last.info.id, part.id])
+        await Storage.remove(['part', last.info.id, part.id]);
         await Bus.publish(MessageV2.Event.PartRemoved, {
           sessionID: sessionID,
           messageID: last.info.id,
           partID: part.id,
-        })
+        });
       }
     }
     await Session.update(sessionID, (draft) => {
-      draft.revert = undefined
-    })
+      draft.revert = undefined;
+    });
   }
 }

package/src/session/status.ts

@@ -1,75 +1,75 @@
-import { Bus } from "../bus"
-import { Instance } from "../project/instance"
-import z from "zod"
+import { Bus } from '../bus';
+import { Instance } from '../project/instance';
+import z from 'zod';
 
 export namespace SessionStatus {
   export const Info = z
     .union([
       z.object({
-        type: z.literal("idle"),
+        type: z.literal('idle'),
       }),
       z.object({
-        type: z.literal("retry"),
+        type: z.literal('retry'),
         attempt: z.number(),
         message: z.string(),
         next: z.number(),
       }),
       z.object({
-        type: z.literal("busy"),
+        type: z.literal('busy'),
       }),
     ])
     .meta({
-      ref: "SessionStatus",
-    })
-  export type Info = z.infer<typeof Info>
+      ref: 'SessionStatus',
+    });
+  export type Info = z.infer<typeof Info>;
 
   export const Event = {
     Status: Bus.event(
-      "session.status",
+      'session.status',
       z.object({
         sessionID: z.string(),
         status: Info,
-      }),
+      })
     ),
     // deprecated
     Idle: Bus.event(
-      "session.idle",
+      'session.idle',
       z.object({
         sessionID: z.string(),
-      }),
+      })
     ),
-  }
+  };
 
   const state = Instance.state(() => {
-    const data: Record<string, Info> = {}
-    return data
-  })
+    const data: Record<string, Info> = {};
+    return data;
+  });
 
   export function get(sessionID: string) {
     return (
       state()[sessionID] ?? {
-        type: "idle",
+        type: 'idle',
       }
-    )
+    );
   }
 
   export function list() {
-    return Object.values(state())
+    return Object.values(state());
   }
 
   export function set(sessionID: string, status: Info) {
     Bus.publish(Event.Status, {
       sessionID,
       status,
-    })
-    if (status.type === "idle") {
+    });
+    if (status.type === 'idle') {
       // deprecated
       Bus.publish(Event.Idle, {
         sessionID,
-      })
-      delete state()[sessionID]
-      return
+      });
+      delete state()[sessionID];
+      return;
     }
-    state()[sessionID] = status
+    state()[sessionID] = status;
   }
 }

package/src/session/summary.ts

@@ -1,21 +1,21 @@
-import { Provider } from "../provider/provider"
-import { fn } from "../util/fn"
-import z from "zod"
-import { Session } from "."
-import { generateText, type ModelMessage } from "ai"
-import { MessageV2 } from "./message-v2"
-import { Identifier } from "../id/id"
-import { Snapshot } from "../snapshot"
-import { ProviderTransform } from "../provider/transform"
-import { SystemPrompt } from "./system"
-import { Log } from "../util/log"
-import path from "path"
-import { Instance } from "../project/instance"
-import { Storage } from "../storage/storage"
-import { Bus } from "../bus"
+import { Provider } from '../provider/provider';
+import { fn } from '../util/fn';
+import z from 'zod';
+import { Session } from '.';
+import { generateText, type ModelMessage } from 'ai';
+import { MessageV2 } from './message-v2';
+import { Identifier } from '../id/id';
+import { Snapshot } from '../snapshot';
+import { ProviderTransform } from '../provider/transform';
+import { SystemPrompt } from './system';
+import { Log } from '../util/log';
+import path from 'path';
+import { Instance } from '../project/instance';
+import { Storage } from '../storage/storage';
+import { Bus } from '../bus';
 
 export namespace SessionSummary {
-  const log = Log.create({ service: "session.summary" })
+  const log = Log.create({ service: 'session.summary' });
 
   export const summarize = fn(
     z.object({
@@ -23,104 +23,122 @@ export namespace SessionSummary {
       messageID: z.string(),
     }),
     async (input) => {
-      const all = await Session.messages({ sessionID: input.sessionID })
+      const all = await Session.messages({ sessionID: input.sessionID });
       await Promise.all([
         summarizeSession({ sessionID: input.sessionID, messages: all }),
         summarizeMessage({ messageID: input.messageID, messages: all }),
-      ])
-    },
-  )
+      ]);
+    }
+  );
 
-  async function summarizeSession(input: { sessionID: string; messages: MessageV2.WithParts[] }) {
+  async function summarizeSession(input: {
+    sessionID: string;
+    messages: MessageV2.WithParts[];
+  }) {
     const files = new Set(
       input.messages
         .flatMap((x) => x.parts)
-        .filter((x) => x.type === "patch")
+        .filter((x) => x.type === 'patch')
         .flatMap((x) => x.files)
-        .map((x) => path.relative(Instance.worktree, x)),
-    )
+        .map((x) => path.relative(Instance.worktree, x))
+    );
     const diffs = await computeDiff({ messages: input.messages }).then((x) =>
       x.filter((x) => {
-        return files.has(x.file)
-      }),
-    )
+        return files.has(x.file);
+      })
+    );
     await Session.update(input.sessionID, (draft) => {
       draft.summary = {
         additions: diffs.reduce((sum, x) => sum + x.additions, 0),
         deletions: diffs.reduce((sum, x) => sum + x.deletions, 0),
         files: diffs.length,
-      }
-    })
-    await Storage.write(["session_diff", input.sessionID], diffs)
+      };
+    });
+    await Storage.write(['session_diff', input.sessionID], diffs);
     Bus.publish(Session.Event.Diff, {
       sessionID: input.sessionID,
       diff: diffs,
-    })
+    });
   }
 
-  async function summarizeMessage(input: { messageID: string; messages: MessageV2.WithParts[] }) {
+  async function summarizeMessage(input: {
+    messageID: string;
+    messages: MessageV2.WithParts[];
+  }) {
     const messages = input.messages.filter(
-      (m) => m.info.id === input.messageID || (m.info.role === "assistant" && m.info.parentID === input.messageID),
-    )
-    const msgWithParts = messages.find((m) => m.info.id === input.messageID)!
-    const userMsg = msgWithParts.info as MessageV2.User
-    const diffs = await computeDiff({ messages })
+      (m) =>
+        m.info.id === input.messageID ||
+        (m.info.role === 'assistant' && m.info.parentID === input.messageID)
+    );
+    const msgWithParts = messages.find((m) => m.info.id === input.messageID)!;
+    const userMsg = msgWithParts.info as MessageV2.User;
+    const diffs = await computeDiff({ messages });
     userMsg.summary = {
       ...userMsg.summary,
       diffs,
-    }
-    await Session.updateMessage(userMsg)
+    };
+    await Session.updateMessage(userMsg);
 
-    const assistantMsg = messages.find((m) => m.info.role === "assistant")!.info as MessageV2.Assistant
-    const small = await Provider.getSmallModel(assistantMsg.providerID)
-    if (!small) return
+    const assistantMsg = messages.find((m) => m.info.role === 'assistant')!
+      .info as MessageV2.Assistant;
+    const small = await Provider.getSmallModel(assistantMsg.providerID);
+    if (!small) return;
 
-    const textPart = msgWithParts.parts.find((p) => p.type === "text" && !p.synthetic) as MessageV2.TextPart
+    const textPart = msgWithParts.parts.find(
+      (p) => p.type === 'text' && !p.synthetic
+    ) as MessageV2.TextPart;
     if (textPart && !userMsg.summary?.title) {
       const result = await generateText({
         maxOutputTokens: small.info.reasoning ? 1500 : 20,
-        providerOptions: ProviderTransform.providerOptions(small.npm, small.providerID, {}),
+        providerOptions: ProviderTransform.providerOptions(
+          small.npm,
+          small.providerID,
+          {}
+        ),
         messages: [
           ...SystemPrompt.title(small.providerID).map(
             (x): ModelMessage => ({
-              role: "system",
+              role: 'system',
               content: x,
-            }),
+            })
           ),
           {
-            role: "user" as const,
+            role: 'user' as const,
             content: `
               The following is the text to summarize:
               <text>
-              ${textPart?.text ?? ""}
+              ${textPart?.text ?? ''}
               </text>
             `,
           },
         ],
         headers: small.info.headers,
         model: small.language,
-      })
-      log.info("title", { title: result.text })
-      userMsg.summary.title = result.text
-      await Session.updateMessage(userMsg)
+      });
+      log.info('title', { title: result.text });
+      userMsg.summary.title = result.text;
+      await Session.updateMessage(userMsg);
     }
 
     if (
       messages.some(
         (m) =>
-          m.info.role === "assistant" && m.parts.some((p) => p.type === "step-finish" && p.reason !== "tool-calls"),
+          m.info.role === 'assistant' &&
+          m.parts.some(
+            (p) => p.type === 'step-finish' && p.reason !== 'tool-calls'
+          )
       )
     ) {
       let summary = messages
-        .findLast((m) => m.info.role === "assistant")
-        ?.parts.findLast((p) => p.type === "text")?.text
+        .findLast((m) => m.info.role === 'assistant')
+        ?.parts.findLast((p) => p.type === 'text')?.text;
       if (!summary || diffs.length > 0) {
         const result = await generateText({
           model: small.language,
           maxOutputTokens: 100,
           messages: [
             {
-              role: "user",
+              role: 'user',
               content: `
             Summarize the following conversation into 2 sentences MAX explaining what the assistant did and why. Do not explain the user's input. Do not speak in the third person about the assistant.
             <conversation>
@@ -130,50 +148,53 @@ export namespace SessionSummary {
             },
           ],
           headers: small.info.headers,
-        }).catch(() => {})
-        if (result) summary = result.text
+        }).catch(() => {});
+        if (result) summary = result.text;
       }
-      userMsg.summary.body = summary
-      log.info("body", { body: summary })
-      await Session.updateMessage(userMsg)
+      userMsg.summary.body = summary;
+      log.info('body', { body: summary });
+      await Session.updateMessage(userMsg);
     }
   }
 
   export const diff = fn(
     z.object({
-      sessionID: Identifier.schema("session"),
-      messageID: Identifier.schema("message").optional(),
+      sessionID: Identifier.schema('session'),
+      messageID: Identifier.schema('message').optional(),
     }),
     async (input) => {
-      return Storage.read<Snapshot.FileDiff[]>(["session_diff", input.sessionID]).catch(() => [])
-    },
-  )
+      return Storage.read<Snapshot.FileDiff[]>([
+        'session_diff',
+        input.sessionID,
+      ]).catch(() => []);
+    }
+  );
 
   async function computeDiff(input: { messages: MessageV2.WithParts[] }) {
-    let from: string | undefined
-    let to: string | undefined
+    let from: string | undefined;
+    let to: string | undefined;
 
     // scan assistant messages to find earliest from and latest to
     // snapshot
     for (const item of input.messages) {
       if (!from) {
         for (const part of item.parts) {
-          if (part.type === "step-start" && part.snapshot) {
-            from = part.snapshot
-            break
+          if (part.type === 'step-start' && part.snapshot) {
+            from = part.snapshot;
+            break;
           }
         }
       }
 
       for (const part of item.parts) {
-        if (part.type === "step-finish" && part.snapshot) {
-          to = part.snapshot
-          break
+        if (part.type === 'step-finish' && part.snapshot) {
+          to = part.snapshot;
+          break;
         }
       }
     }
 
-    if (from && to) return Snapshot.diffFull(from, to)
-    return []
+    if (from && to) return Snapshot.diffFull(from, to);
+    return [];
   }
 }