@lite-agent/core 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -250,6 +250,7 @@ interface CreateAgentConfig {
     maxTokens?: number;
     sandbox?: Sandbox;
     input?: InputHandler;
+    store?: Store;
 }
 type RunOptions = {
     signal?: AbortSignal;
@@ -275,6 +276,108 @@ declare function fakeProvider(turns: FakeTurn[]): ModelProvider;
 
 declare function noopSandbox(): Sandbox;
 
+declare function memoryStore(): Store;
+
+interface RetryOptions {
+    /** Retries after the first attempt. Default 2 (→ up to 3 total attempts). */
+    maxRetries?: number;
+    /** ms to wait before retry N (1-based). Default exponential 250ms→8s. */
+    backoff?: (attempt: number) => number;
+    /** Whether an error is retryable. Default: transient ProviderError. */
+    retryOn?: (err: unknown) => boolean;
+}
+declare function retry(opts?: RetryOptions): Middleware;
+
+declare const SPILL_PREFIX = "[spilled:";
+interface CompactPass {
+    readonly name: string;
+    apply(messages: Message[]): Message[];
+}
+declare function runPipeline(passes: CompactPass[], messages: Message[]): Message[];
+declare function estimateTokens(messages: Message[]): number;
+
+interface MicroPassOptions {
+    /** How many of the most recent tool_results keep their full body. Default 3. */
+    keepRecent?: number;
+    placeholder?: string;
+}
+declare function microPass(opts?: MicroPassOptions): CompactPass;
+
+interface SnipPassOptions {
+    /** Only snip when the transcript exceeds this many messages. Default 50. */
+    maxMessages?: number;
+    /** How many leading turns to always keep. Default 1. */
+    headTurns?: number;
+    /** Keep trailing turns until at least this many messages are retained. Default 20. */
+    tailKeep?: number;
+}
+declare function splitTurns(messages: Message[]): Message[][];
+declare function snipPass(opts?: SnipPassOptions): CompactPass;
+
+interface SpillStore {
+    put(content: string): string;
+    get(ref: string): string | null;
+}
+declare function memorySpillStore(): SpillStore;
+interface ToolResultBudgetOptions {
+    store: SpillStore;
+    /** Spill the largest tool_results until total body bytes ≤ this. Default 200_000. */
+    budgetBytes?: number;
+}
+declare function toolResultBudgetPass(opts: ToolResultBudgetOptions): CompactPass;
+
+interface DefaultCompactorOptions {
+    /** snip: only snip beyond this many messages. Default 50. */
+    maxMessages?: number;
+    /** snip: leading turns always kept. Default 1. */
+    headTurns?: number;
+    /** snip: keep trailing turns until this many messages retained. Default 20. */
+    tailKeep?: number;
+    /** micro: how many recent tool_results keep full bodies. Default 3. */
+    keepRecentToolResults?: number;
+    /** L3: when set, spill oversized tool_results to this store (runs first). */
+    spillStore?: SpillStore;
+    /** L3: spill largest tool_results until total body bytes ≤ this. Default 200_000. */
+    budgetBytes?: number;
+    /** Replace the whole pass pipeline (hot-swap). Defaults to [spill?] → snip → micro. */
+    passes?: CompactPass[];
+}
+declare function defaultCompactor(opts?: DefaultCompactorOptions): Compactor;
+
+declare function compaction(compactor: Compactor): Middleware;
+
+interface ReactiveTrimOptions {
+    /** Max recent turns to keep. Default 2. */
+    keepTurns?: number;
+    /** Approx token cap on the kept tail. Default 4000. */
+    tokenBudget?: number;
+}
+declare function reactiveTrim(messages: Message[], opts?: ReactiveTrimOptions): Message[];
+interface ReactiveCompactionOptions {
+    /** How to trim on overflow. Default reactiveTrim with its defaults. */
+    trim?: (messages: Message[]) => Message[];
+    /** Classify an error as a context-overflow. Default: ProviderError 413 / prompt_too_long. */
+    isOverflow?: (err: unknown) => boolean;
+    /** Reactive retries after the first failure. Default 1. */
+    maxAttempts?: number;
+}
+declare function reactiveCompaction(opts?: ReactiveCompactionOptions): Middleware;
+
+interface LlmCompactorOptions {
+    provider: ModelProvider;
+    model: string;
+    /** Deterministic compactor run first. Default defaultCompactor(). */
+    base?: Compactor;
+    /** Summarize via the LLM once the estimate exceeds this. Default 120_000. */
+    tokenThreshold?: number;
+    /** Recent turns kept verbatim; older ones get summarized. Default 3. */
+    keepRecentTurns?: number;
+    summaryPrompt?: string;
+    /** Consecutive LLM failures before the circuit opens (falls back to base). Default 2. */
+    maxFailures?: number;
+}
+declare function llmCompactor(opts: LlmCompactorOptions): Compactor;
+
 interface PolicyOptions {
     allow?: string[];
     ask?: string[];
@@ -284,4 +387,4 @@ interface PolicyOptions {
 declare function policy(opts?: PolicyOptions): PermissionPolicy;
 declare function permission(pol: PermissionPolicy, approval?: ApprovalHandler): Middleware;
 
-export { AbortError, type Agent, type AgentContext, AgentError, type AgentEvent, type ApprovalHandler, type AssistantMessage, CodecError, type CompactResult, type Compactor, type ContentBlock, type CreateAgentConfig, type Decision, type FakeTurn, type InputHandler, MaxTurnsError, type Message, type Middleware, type ModelCall, type ModelChunk, type ModelProvider, type ModelRequest, type PermissionPolicy, type PolicyContext, type PolicyOptions, ProviderError, type Role, type RunOptions, type RunResult, type Sandbox, type SandboxWrapOptions, type StopReason, type Store, type TextBlock, type Tool, type ToolCall, type ToolCallBlock, type ToolCallCodec, type ToolCallContext, type ToolContext, ToolError, type ToolExec, type ToolResult, type ToolResultBlock, type ToolSpec, type Usage, type UserAnswer, type UserQuestion, composeModelCall, composeToolCall, createAgent, defineTool, fakeProvider, isTextBlock, isToolCallBlock, nativeCodec, noopSandbox, permission, policy, runLifecycle, textBlock, toToolSpec, toolResultBlock };
+export { AbortError, type Agent, type AgentContext, AgentError, type AgentEvent, type ApprovalHandler, type AssistantMessage, CodecError, type CompactPass, type CompactResult, type Compactor, type ContentBlock, type CreateAgentConfig, type Decision, type DefaultCompactorOptions, type FakeTurn, type InputHandler, type LlmCompactorOptions, MaxTurnsError, type Message, type MicroPassOptions, type Middleware, type ModelCall, type ModelChunk, type ModelProvider, type ModelRequest, type PermissionPolicy, type PolicyContext, type PolicyOptions, ProviderError, type ReactiveCompactionOptions, type ReactiveTrimOptions, type RetryOptions, type Role, type RunOptions, type RunResult, SPILL_PREFIX, type Sandbox, type SandboxWrapOptions, type SnipPassOptions, type SpillStore, type StopReason, type Store, type TextBlock, type Tool, type ToolCall, type ToolCallBlock, type ToolCallCodec, type ToolCallContext, type ToolContext, ToolError, type ToolExec, type ToolResult, type ToolResultBlock, type ToolResultBudgetOptions, type ToolSpec, type Usage, type UserAnswer, type UserQuestion, compaction, composeModelCall, composeToolCall, createAgent, defaultCompactor, defineTool, estimateTokens, fakeProvider, isTextBlock, isToolCallBlock, llmCompactor, memorySpillStore, memoryStore, microPass, nativeCodec, noopSandbox, permission, policy, reactiveCompaction, reactiveTrim, retry, runLifecycle, runPipeline, snipPass, splitTurns, textBlock, toToolSpec, toolResultBlock, toolResultBudgetPass };

package/dist/index.js

@@ -74,6 +74,13 @@ function toToolSpec(tool) {
 // src/kernel.ts
 async function* runKernel(cfg, input, signal, sessionId) {
   let messages = typeof input === "string" ? [{ role: "user", content: input }] : [...input];
+  if (cfg.store) {
+    const saved = await cfg.store.load(sessionId);
+    if (saved) messages = [...saved, ...messages];
+  }
+  const persist = async () => {
+    if (cfg.store) await cfg.store.save(sessionId, messages);
+  };
   const queue = [];
   const emit = (ev) => {
     queue.push(ev);
@@ -99,11 +106,17 @@ async function* runKernel(cfg, input, signal, sessionId) {
     await runLifecycle(cfg.middleware, "beforeModel", ctx);
     yield* drain();
     messages = ctx.messages;
-    const req = cfg.codec.encode(
-      { model: cfg.model, system: cfg.system, messages: ctx.messages, maxTokens: cfg.maxTokens },
-      toolSpecs
+    const modelCall = composeModelCall(
+      cfg.middleware,
+      ctx,
+      () => cfg.provider.stream(
+        cfg.codec.encode(
+          { model: cfg.model, system: cfg.system, messages: ctx.messages, maxTokens: cfg.maxTokens },
+          toolSpecs
+        ),
+        signal
+      )
     );
-    const modelCall = composeModelCall(cfg.middleware, ctx, () => cfg.provider.stream(req, signal));
     let assistant;
     for await (const chunk of modelCall()) {
       if (chunk.type === "text_delta") yield { type: "text_delta", text: chunk.text };
@@ -115,6 +128,7 @@ async function* runKernel(cfg, input, signal, sessionId) {
         };
       }
     }
+    messages = ctx.messages;
     yield* drain();
     if (!assistant) throw new ProviderError("provider produced no message_done chunk");
     ctx.messages.push(assistant);
@@ -146,10 +160,12 @@ async function* runKernel(cfg, input, signal, sessionId) {
       yield { type: "tool_result", result: result2 };
     }
     ctx.messages.push({ role: "user", content: resultBlocks });
+    await persist();
     yield { type: "turn_end", turn, stopReason: "tool_use" };
   }
   await runLifecycle(cfg.middleware, "afterAgent", mkCtx(0));
   yield* drain();
+  await persist();
   const result = { messages, text: lastAssistantText(messages), usage, stopReason };
   yield { type: "done", reason: stopReason, result };
   return result;
@@ -177,7 +193,8 @@ function createAgent(cfg) {
     maxTurns: cfg.maxTurns ?? 50,
     maxTokens: cfg.maxTokens,
     sandbox: cfg.sandbox ?? noopSandbox(),
-    input: cfg.input
+    input: cfg.input,
+    store: cfg.store
   };
   const agent = {
     run(input, opts) {
@@ -232,6 +249,343 @@ function fakeProvider(turns) {
   };
 }
 
+// src/store.ts
+function memoryStore() {
+  const sessions = /* @__PURE__ */ new Map();
+  return {
+    async load(id) {
+      return sessions.get(id) ?? null;
+    },
+    async save(id, messages) {
+      sessions.set(id, structuredClone(messages));
+    }
+  };
+}
+
+// src/retry.ts
+var TRANSIENT = /* @__PURE__ */ new Set([408, 409, 425, 429, 500, 502, 503, 504]);
+var defaultRetryOn = (err) => err instanceof ProviderError && (err.status === void 0 || TRANSIENT.has(err.status));
+var defaultBackoff = (attempt) => Math.min(250 * 2 ** (attempt - 1), 8e3);
+function retry(opts = {}) {
+  const maxRetries = opts.maxRetries ?? 2;
+  const backoff = opts.backoff ?? defaultBackoff;
+  const retryOn = opts.retryOn ?? defaultRetryOn;
+  return {
+    name: "retry",
+    async *wrapModelCall(ctx, next) {
+      let attempt = 0;
+      while (true) {
+        let started = false;
+        try {
+          for await (const chunk of next()) {
+            started = true;
+            yield chunk;
+          }
+          return;
+        } catch (err) {
+          if (started || attempt >= maxRetries || !retryOn(err)) throw err;
+          attempt++;
+          const ms = backoff(attempt);
+          if (ms > 0) await new Promise((r) => setTimeout(r, ms));
+        }
+      }
+    }
+  };
+}
+
+// src/compaction/types.ts
+var SPILL_PREFIX = "[spilled:";
+function runPipeline(passes, messages) {
+  return passes.reduce((msgs, pass) => pass.apply(msgs), messages);
+}
+function estimateTokens(messages) {
+  let chars = 0;
+  for (const m of messages) {
+    if (typeof m.content === "string") {
+      chars += m.content.length;
+      continue;
+    }
+    for (const b of m.content) {
+      if (b.type === "text") chars += b.text.length;
+      else if (b.type === "tool_result") chars += b.content.length;
+      else if (b.type === "tool_call") chars += JSON.stringify(b.input).length;
+    }
+  }
+  return Math.ceil(chars / 4);
+}
+
+// src/compaction/micro.ts
+function microPass(opts = {}) {
+  const keepRecent = opts.keepRecent ?? 3;
+  const placeholder = opts.placeholder ?? "[tool result omitted to save context]";
+  return {
+    name: "micro",
+    apply(messages) {
+      const positions = [];
+      messages.forEach((m, mi) => {
+        if (Array.isArray(m.content)) {
+          m.content.forEach((b, bi) => {
+            if (b.type === "tool_result") positions.push([mi, bi]);
+          });
+        }
+      });
+      if (positions.length <= keepRecent) return messages;
+      const omit = new Set(positions.slice(0, positions.length - keepRecent).map(([mi, bi]) => `${mi}:${bi}`));
+      let anyChanged = false;
+      const out = messages.map((m, mi) => {
+        if (!Array.isArray(m.content)) return m;
+        let changed = false;
+        const content = m.content.map((b, bi) => {
+          if (b.type === "tool_result" && omit.has(`${mi}:${bi}`) && b.content !== placeholder && !b.content.startsWith(SPILL_PREFIX)) {
+            changed = true;
+            return { ...b, content: placeholder };
+          }
+          return b;
+        });
+        if (!changed) return m;
+        anyChanged = true;
+        return { ...m, content };
+      });
+      return anyChanged ? out : messages;
+    }
+  };
+}
+
+// src/compaction/snip.ts
+function splitTurns(messages) {
+  const turns = [];
+  let cur = [];
+  for (const m of messages) {
+    if (m.role === "user" && typeof m.content === "string" && cur.length > 0) {
+      turns.push(cur);
+      cur = [];
+    }
+    cur.push(m);
+  }
+  if (cur.length) turns.push(cur);
+  return turns;
+}
+function snipPass(opts = {}) {
+  const maxMessages = opts.maxMessages ?? 50;
+  const headTurns = opts.headTurns ?? 1;
+  const tailKeep = opts.tailKeep ?? 20;
+  return {
+    name: "snip",
+    apply(messages) {
+      if (messages.length <= maxMessages) return messages;
+      const turns = splitTurns(messages);
+      let tailTurnCount = 0;
+      let tailMsgCount = 0;
+      for (let i = turns.length - 1; i >= 0 && tailMsgCount < tailKeep; i--) {
+        tailMsgCount += turns[i].length;
+        tailTurnCount++;
+      }
+      if (headTurns + tailTurnCount >= turns.length) return messages;
+      const head = turns.slice(0, headTurns).flat();
+      const tail = turns.slice(turns.length - tailTurnCount).flat();
+      const omitted = turns.length - headTurns - tailTurnCount;
+      const placeholder = { role: "user", content: `[${omitted} earlier turn(s) omitted to save context]` };
+      return [...head, placeholder, ...tail];
+    }
+  };
+}
+
+// src/compaction/budget.ts
+function memorySpillStore() {
+  const blobs = /* @__PURE__ */ new Map();
+  let n = 0;
+  return {
+    put(content) {
+      const ref = `m${++n}`;
+      blobs.set(ref, content);
+      return ref;
+    },
+    get(ref) {
+      return blobs.get(ref) ?? null;
+    }
+  };
+}
+var isSpilled = (s) => s.startsWith(SPILL_PREFIX);
+var marker = (ref, bytes) => `${SPILL_PREFIX}${ref}] ${bytes} bytes moved off-context \u2014 call read_spilled({ ref: "${ref}" }) to view the full content.`;
+function toolResultBudgetPass(opts) {
+  const budget = opts.budgetBytes ?? 2e5;
+  return {
+    name: "toolResultBudget",
+    apply(messages) {
+      const results = [];
+      let total = 0;
+      messages.forEach((m, mi) => {
+        if (Array.isArray(m.content)) {
+          m.content.forEach((b, bi) => {
+            if (b.type === "tool_result" && !isSpilled(b.content)) {
+              results.push({ mi, bi, bytes: b.content.length });
+              total += b.content.length;
+            }
+          });
+        }
+      });
+      if (total <= budget) return messages;
+      results.sort((a, b) => b.bytes - a.bytes);
+      const spill = /* @__PURE__ */ new Set();
+      for (const r of results) {
+        if (total <= budget) break;
+        spill.add(`${r.mi}:${r.bi}`);
+        total -= r.bytes;
+      }
+      if (spill.size === 0) return messages;
+      return messages.map((m, mi) => {
+        if (!Array.isArray(m.content)) return m;
+        let changed = false;
+        const content = m.content.map((b, bi) => {
+          if (b.type === "tool_result" && spill.has(`${mi}:${bi}`)) {
+            changed = true;
+            const ref = opts.store.put(b.content);
+            return { ...b, content: marker(ref, b.content.length) };
+          }
+          return b;
+        });
+        return changed ? { ...m, content } : m;
+      });
+    }
+  };
+}
+
+// src/compaction/defaultCompactor.ts
+function defaultCompactor(opts = {}) {
+  const passes = opts.passes ?? [
+    ...opts.spillStore ? [toolResultBudgetPass({ store: opts.spillStore, budgetBytes: opts.budgetBytes })] : [],
+    snipPass({ maxMessages: opts.maxMessages, headTurns: opts.headTurns, tailKeep: opts.tailKeep }),
+    microPass({ keepRecent: opts.keepRecentToolResults })
+  ];
+  return {
+    async maybeCompact(messages) {
+      const before = estimateTokens(messages);
+      const out = runPipeline(passes, messages);
+      if (out === messages) return { messages, before, after: before };
+      return { messages: out, kind: "micro", before, after: estimateTokens(out) };
+    }
+  };
+}
+
+// src/compaction/middleware.ts
+var ZERO_USAGE = { inputTokens: 0, outputTokens: 0 };
+function compaction(compactor) {
+  return {
+    name: "compaction",
+    async beforeModel(ctx) {
+      const r = await compactor.maybeCompact(ctx.messages, ZERO_USAGE);
+      if (r.messages !== ctx.messages) {
+        ctx.emit({ type: "compaction", kind: r.kind ?? "micro", before: r.before ?? 0, after: r.after ?? 0 });
+        ctx.messages = r.messages;
+      }
+    }
+  };
+}
+
+// src/compaction/reactive.ts
+function reactiveTrim(messages, opts = {}) {
+  const keepTurns = opts.keepTurns ?? 2;
+  const budget = opts.tokenBudget ?? 4e3;
+  const turns = splitTurns(messages);
+  const kept = [];
+  let toks = 0;
+  for (let i = turns.length - 1; i >= 0; i--) {
+    const t = turns[i];
+    if (kept.length >= 1 && (kept.length >= keepTurns || toks + estimateTokens(t) > budget)) break;
+    kept.unshift(t);
+    toks += estimateTokens(t);
+  }
+  const dropped = turns.length - kept.length;
+  if (dropped <= 0) return messages;
+  const placeholder = { role: "user", content: `[${dropped} earlier turn(s) dropped \u2014 context overflow]` };
+  return [placeholder, ...kept.flat()];
+}
+function defaultIsOverflow(err) {
+  if (!(err instanceof ProviderError)) return false;
+  if (err.status === 413) return true;
+  return /prompt[\s_]?too[\s_]?long|context[\s_]?length|too many tokens|maximum context/i.test(err.message);
+}
+function reactiveCompaction(opts = {}) {
+  const trim = opts.trim ?? ((m) => reactiveTrim(m));
+  const isOverflow = opts.isOverflow ?? defaultIsOverflow;
+  const maxAttempts = opts.maxAttempts ?? 1;
+  return {
+    name: "reactive-compaction",
+    async *wrapModelCall(ctx, next) {
+      let attempts = 0;
+      while (true) {
+        let started = false;
+        try {
+          for await (const chunk of next()) {
+            started = true;
+            yield chunk;
+          }
+          return;
+        } catch (err) {
+          if (started || !isOverflow(err) || attempts >= maxAttempts) throw err;
+          attempts++;
+          const before = estimateTokens(ctx.messages);
+          ctx.messages = trim(ctx.messages);
+          ctx.emit({ type: "compaction", kind: "auto", before, after: estimateTokens(ctx.messages) });
+        }
+      }
+    }
+  };
+}
+
+// src/compaction/llm.ts
+var DEFAULT_SUMMARY_PROMPT = "You are a context-compaction assistant. Summarize the conversation so far into a concise note that preserves key facts, decisions, file paths, and the current task state. Output only the summary.";
+function llmCompactor(opts) {
+  const base = opts.base ?? defaultCompactor();
+  const threshold = opts.tokenThreshold ?? 12e4;
+  const keepRecentTurns = opts.keepRecentTurns ?? 3;
+  const summaryPrompt = opts.summaryPrompt ?? DEFAULT_SUMMARY_PROMPT;
+  const maxFailures = opts.maxFailures ?? 2;
+  let failures = 0;
+  let circuitOpen = false;
+  async function summarize(older) {
+    const req = {
+      model: opts.model,
+      system: summaryPrompt,
+      messages: [...older, { role: "user", content: "Summarize the conversation above as instructed." }]
+    };
+    let assistant;
+    for await (const chunk of opts.provider.stream(req)) {
+      if (chunk.type === "message_done") assistant = chunk.message;
+    }
+    if (!assistant || !Array.isArray(assistant.content)) return "";
+    return assistant.content.filter(isTextBlock).map((b) => b.text).join("").trim();
+  }
+  return {
+    async maybeCompact(messages, usage) {
+      const before = estimateTokens(messages);
+      const baseResult = await base.maybeCompact(messages, usage);
+      const msgs = baseResult.messages;
+      if (circuitOpen || estimateTokens(msgs) <= threshold) {
+        return { ...baseResult, before, after: estimateTokens(msgs) };
+      }
+      const turns = splitTurns(msgs);
+      if (turns.length <= keepRecentTurns + 1) {
+        return { messages: msgs, kind: baseResult.kind, before, after: estimateTokens(msgs) };
+      }
+      const recent = turns.slice(turns.length - keepRecentTurns).flat();
+      const older = turns.slice(0, turns.length - keepRecentTurns).flat();
+      try {
+        const summary = await summarize(older);
+        failures = 0;
+        const summaryMsg = { role: "user", content: `[Summary of earlier conversation]
+${summary}` };
+        const out = [summaryMsg, ...recent];
+        return { messages: out, kind: "auto", before, after: estimateTokens(out) };
+      } catch {
+        failures++;
+        if (failures >= maxFailures) circuitOpen = true;
+        return { messages: msgs, kind: baseResult.kind, before, after: estimateTokens(msgs) };
+      }
+    }
+  };
+}
+
 // src/permission.ts
 function globToRegExp(pattern) {
   const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
@@ -276,20 +630,35 @@ export {
   CodecError,
   MaxTurnsError,
   ProviderError,
+  SPILL_PREFIX,
   ToolError,
+  compaction,
   composeModelCall,
   composeToolCall,
   createAgent,
+  defaultCompactor,
   defineTool,
+  estimateTokens,
   fakeProvider,
   isTextBlock,
   isToolCallBlock,
+  llmCompactor,
+  memorySpillStore,
+  memoryStore,
+  microPass,
   nativeCodec,
   noopSandbox,
   permission,
   policy,
+  reactiveCompaction,
+  reactiveTrim,
+  retry,
   runLifecycle,
+  runPipeline,
+  snipPass,
+  splitTurns,
   textBlock,
   toToolSpec,
-  toolResultBlock
+  toolResultBlock,
+  toolResultBudgetPass
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lite-agent/core",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Pluggable, event-driven agent core: kernel, strategy interfaces, middleware pipeline, and normalized types.",
   "license": "ISC",
   "type": "module",
@@ -34,11 +34,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean --tsconfig tsconfig.build.json",
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit"
-  },
   "dependencies": {
     "zod": "^4.3.6"
   },
@@ -47,5 +42,10 @@
     "tsup": "^8.3.0",
     "typescript": "^6.0.2",
     "vitest": "^2.1.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean --tsconfig tsconfig.build.json",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
   }
-}
+}