@cjhyy/code-shell 0.1.0-alpha.1 → 0.1.0-alpha.2

package/dist/chunk-JHNCK7JP.cjs

@@ -0,0 +1,202 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
+
+// src/logging/logger.ts
+_chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+
+
+
+
+
+
+
+var _fs = require('fs');
+var _path = require('path');
+var _os = require('os');
+var LEVEL_ORDER = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var LOGS_DIR = _path.join.call(void 0, _os.homedir.call(void 0, ), ".code-shell", "logs");
+var MAX_LOG_FILES = 7;
+var MAX_IN_MEMORY_ERRORS = 100;
+function isLocalDev() {
+  if (process.env.CODE_SHELL_DEV === "1") return true;
+  if (process.argv.includes("--debug") || process.argv.includes("-d")) return true;
+  if (process.argv.some((a) => a.startsWith("--debug="))) return true;
+  if (process.env.NODE_ENV === "test" || process.env.BUN_TEST === "1") return false;
+  if (process.argv.some((a) => a.includes("/tests/") || a.endsWith(".test.ts"))) return false;
+  const entry = _nullishCoalesce(process.argv[1], () => ( ""));
+  if (entry.includes(`${"/"}src${"/"}`)) return true;
+  return false;
+}
+function resolveDefaultLevel() {
+  const raw = _optionalChain([process, 'access', _ => _.env, 'access', _2 => _2.CODE_SHELL_LOG_LEVEL, 'optionalAccess', _3 => _3.toLowerCase, 'call', _4 => _4(), 'access', _5 => _5.trim, 'call', _6 => _6()]);
+  if (raw && Object.hasOwn(LEVEL_ORDER, raw)) return raw;
+  return isLocalDev() ? "debug" : "info";
+}
+function resolveCategoryFilter() {
+  const cliArg = process.argv.find((a) => a.startsWith("--debug="));
+  let raw;
+  if (cliArg) raw = cliArg.slice("--debug=".length);
+  else {
+    const env = process.env.CODE_SHELL_DEBUG;
+    if (env && env !== "1" && env !== "true") raw = env;
+  }
+  if (!raw) return null;
+  const set = new Set(
+    raw.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean)
+  );
+  return set.size > 0 ? set : null;
+}
+var _currentSid = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+function setCurrentSid(sid) {
+  _currentSid = sid;
+}
+function getCurrentSid() {
+  return _currentSid;
+}
+var inMemoryErrors = [];
+var errorLogSink = null;
+var Logger = (_class = class _Logger {
+  constructor(context = {}) {;_class.prototype.__init.call(this);
+    this.context = context;
+    this.enabled = process.env.CODE_SHELL_LOG !== "0";
+    this.minLevel = resolveDefaultLevel();
+    this.categoryFilter = resolveCategoryFilter();
+    this.stderrEcho = process.env.CODE_SHELL_DEBUG === "1" || process.argv.includes("--debug-to-stderr") || process.argv.includes("-d2e");
+  }
+  
+  
+  
+  
+  __init() {this.dirReady = false}
+  child(extra) {
+    return new _Logger({ ...this.context, ...extra });
+  }
+  /**
+   * Set the session id stamped on every subsequent log entry written by
+   * any logger in the process. Called by Engine once a run's
+   * authoritative session id is known.
+   */
+  setSid(sid) {
+    setCurrentSid(sid);
+  }
+  getSid() {
+    return getCurrentSid();
+  }
+  debug(msg, data) {
+    this.write("debug", msg, data);
+  }
+  info(msg, data) {
+    this.write("info", msg, data);
+  }
+  warn(msg, data) {
+    this.write("warn", msg, data);
+  }
+  error(msgOrErr, data) {
+    let msg;
+    let entryData;
+    let errObj;
+    if (typeof msgOrErr === "string") {
+      msg = msgOrErr;
+      if (data instanceof Error) {
+        errObj = data;
+        entryData = { error: data.message, stack: data.stack };
+      } else {
+        entryData = data;
+      }
+    } else if (msgOrErr instanceof Error) {
+      msg = msgOrErr.message;
+      errObj = msgOrErr;
+      entryData = { stack: msgOrErr.stack };
+    } else {
+      msg = String(msgOrErr);
+    }
+    this.recordError(msg, entryData);
+    this.write("error", msg, entryData);
+    if (errObj) _optionalChain([errorLogSink, 'optionalAccess', _7 => _7.logError, 'call', _8 => _8(errObj)]);
+  }
+  recordError(msg, data) {
+    if (inMemoryErrors.length >= MAX_IN_MEMORY_ERRORS) inMemoryErrors.shift();
+    inMemoryErrors.push({ msg, t: (/* @__PURE__ */ new Date()).toISOString(), data });
+  }
+  write(level, msg, data) {
+    if (!this.enabled) return;
+    if (LEVEL_ORDER[level] < LEVEL_ORDER[this.minLevel]) return;
+    const cat = _nullishCoalesce(_optionalChain([data, 'optionalAccess', _9 => _9.cat]), () => ( this.context.cat));
+    if (level === "debug" && this.categoryFilter) {
+      if (!cat || !this.categoryFilter.has(cat.toLowerCase())) return;
+    }
+    const t = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = { t, l: level, msg, ...this.context };
+    if (cat && !entry.cat) entry.cat = cat;
+    if (entry.sid === void 0) entry.sid = _currentSid;
+    if (data) entry.d = data;
+    const line = JSON.stringify(entry) + "\n";
+    if (this.stderrEcho) {
+      process.stderr.write(line);
+      return;
+    }
+    try {
+      if (!this.dirReady) {
+        if (!_fs.existsSync.call(void 0, LOGS_DIR)) _fs.mkdirSync.call(void 0, LOGS_DIR, { recursive: true });
+        this.dirReady = true;
+      }
+      const dateStr = t.slice(0, 10);
+      _fs.appendFileSync.call(void 0, _path.join.call(void 0, LOGS_DIR, `${dateStr}.log`), line, "utf-8");
+    } catch (e) {
+    }
+  }
+  getMinLevel() {
+    return this.minLevel;
+  }
+  isCategoryActive(cat) {
+    return !this.categoryFilter || this.categoryFilter.has(cat.toLowerCase());
+  }
+  /**
+   * Open a span: writes a `<name>.begin` debug entry now and returns a handle
+   * whose `end()` writes `<name>.end` with `duration_ms` populated. Use for
+   * any "I want begin → end + how long" pattern (tool exec, LLM request,
+   * permission ask, etc.) so the begin/end pair is grouped under one cat
+   * and the duration is computed once instead of by hand from timestamps.
+   */
+  span(name, data) {
+    const startedAt = Date.now();
+    this.write("debug", `${name}.begin`, data);
+    return {
+      end: (extra) => {
+        const duration_ms = Date.now() - startedAt;
+        this.write("info", `${name}.end`, { ...data, ...extra, duration_ms });
+      },
+      fail: (err, extra) => {
+        const duration_ms = Date.now() - startedAt;
+        const message = err instanceof Error ? err.message : String(err);
+        this.write("error", `${name}.fail`, { ...data, ...extra, duration_ms, error: message });
+      }
+    };
+  }
+}, _class);
+var logger = new Logger();
+function rotateLogs() {
+  try {
+    if (!_fs.existsSync.call(void 0, LOGS_DIR)) return;
+    const files = _fs.readdirSync.call(void 0, LOGS_DIR).filter((f) => f.endsWith(".log")).sort();
+    if (files.length <= MAX_LOG_FILES) return;
+    for (const f of files.slice(0, files.length - MAX_LOG_FILES)) {
+      try {
+        _fs.unlinkSync.call(void 0, _path.join.call(void 0, LOGS_DIR, f));
+      } catch (e2) {
+      }
+    }
+  } catch (e3) {
+  }
+}
+
+
+
+
+exports.logger = logger; exports.rotateLogs = rotateLogs;

package/dist/{chunk-MOILS4WE.cjs → chunk-JHXNOB5G.cjs}

@@ -1,7 +1,7 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
 
 
-var _chunkQ6BYFYGDcjs = require('./chunk-Q6BYFYGD.cjs');
+var _chunkVWFET3MGcjs = require('./chunk-VWFET3MG.cjs');
 
 
 var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
@@ -15,8 +15,8 @@ var _path = require('path');
 var _os = require('os');
 function createRunManager(options) {
   const runsDir = _nullishCoalesce(options.runsDir, () => ( _path.join.call(void 0, _os.homedir.call(void 0, ), ".code-shell", "runs")));
-  const store = new (0, _chunkQ6BYFYGDcjs.FileRunStore)(runsDir);
-  return new (0, _chunkQ6BYFYGDcjs.RunManager)({
+  const store = new (0, _chunkVWFET3MGcjs.FileRunStore)(runsDir);
+  return new (0, _chunkVWFET3MGcjs.RunManager)({
     store,
     executor: {
       llm: options.llm,

package/dist/{chunk-UK2SU23S.cjs → chunk-KOGV6PDQ.cjs}

@@ -4,6 +4,17 @@ var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
 
 // src/llm/model-pool.ts
 _chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+var BUILTIN_CONTEXT_WINDOWS = [
+  // DeepSeek V4 family — 1M context (api-docs.deepseek.com)
+  [/^deepseek-v4(?:-|$)/i, 1e6],
+  [/(?:^|\/)deepseek-v4(?:-|$)/i, 1e6]
+];
+function lookupBuiltinContextWindow(model) {
+  for (const [re, tokens] of BUILTIN_CONTEXT_WINDOWS) {
+    if (re.test(model)) return tokens;
+  }
+  return void 0;
+}
 var ModelPool = (_class = class {
   __init() {this.models = /* @__PURE__ */ new Map()}
   
@@ -14,7 +25,7 @@ var ModelPool = (_class = class {
   constructor(entries, defaultKey) {;_class.prototype.__init.call(this);
     if (entries) {
       for (const e of entries) {
-        this.models.set(e.key, e);
+        this.models.set(e.key, this.withBuiltinDefaults(e));
       }
     }
     if (defaultKey && this.models.has(defaultKey)) {
@@ -25,11 +36,18 @@ var ModelPool = (_class = class {
   }
   /** Register a model at runtime. */
   register(entry) {
-    this.models.set(entry.key, entry);
+    this.models.set(entry.key, this.withBuiltinDefaults(entry));
     if (!this.activeKey) {
       this.activeKey = entry.key;
     }
   }
+  /** Fill in known defaults (e.g. context window for DeepSeek V4) when the entry doesn't specify them. */
+  withBuiltinDefaults(entry) {
+    if (entry.maxContextTokens != null) return entry;
+    const builtin = lookupBuiltinContextWindow(entry.model);
+    if (builtin == null) return entry;
+    return { ...entry, maxContextTokens: builtin };
+  }
   /** Switch the active model. Throws if key not found. */
   switch(key) {
     const entry = this.models.get(key);

package/dist/{chunk-VKGNCYRL.js → chunk-LMEKCQX4.js}

@@ -1,11 +1,14 @@
 import {
   LLMClientBase
-} from "./chunk-O6F2EF2Z.js";
+} from "./chunk-SCDKLTN3.js";
 import {
   ContextLimitError,
   LLMError,
   LLMRateLimitError
 } from "./chunk-FUOKLKR2.js";
+import {
+  logger
+} from "./chunk-ZRVPCXI7.js";
 import {
   init_esm_shims
 } from "./chunk-DI7RDLOS.js";
@@ -34,10 +37,28 @@ var OpenAIClient = class extends LLMClientBase {
     return this.withRetry(async () => {
       const messages = this.buildMessages(options.systemPrompt, options.messages);
       const tools = options.tools?.length ? this.convertTools(options.tools) : void 0;
-      if (options.stream && options.onChunk) {
-        return this.streamMessage(options, messages, tools);
+      const span = logger.span("llm.request", {
+        cat: "llm",
+        provider: this.provider,
+        model: this.model,
+        stream: !!(options.stream && options.onChunk),
+        messageCount: messages.length,
+        toolCount: tools?.length ?? 0
+      });
+      try {
+        const response = options.stream && options.onChunk ? await this.streamMessage(options, messages, tools) : await this.nonStreamMessage(options, messages, tools);
+        span.end({
+          stopReason: response.stopReason,
+          promptTokens: response.usage?.promptTokens,
+          completionTokens: response.usage?.completionTokens,
+          cacheReadTokens: response.usage?.cacheReadTokens,
+          cacheCreationTokens: response.usage?.cacheCreationTokens
+        });
+        return response;
+      } catch (err) {
+        span.fail(err);
+        throw err;
       }
-      return this.nonStreamMessage(options, messages, tools);
     });
   }
   async nonStreamMessage(options, messages, tools) {
@@ -81,15 +102,31 @@ var OpenAIClient = class extends LLMClientBase {
         { signal: options.signal }
       );
       let text = "";
+      let reasoningContent = "";
       const toolCallsMap = /* @__PURE__ */ new Map();
       let streamUsage;
+      const streamStartedAt = Date.now();
+      let firstByteLogged = false;
       for await (const chunk of stream) {
         if (chunk.usage) {
           streamUsage = chunk.usage;
         }
         const delta = chunk.choices[0]?.delta;
         if (!delta) continue;
+        const reasoningDelta = delta.reasoning_content;
+        if (typeof reasoningDelta === "string" && reasoningDelta.length > 0) {
+          reasoningContent += reasoningDelta;
+        }
         if (delta.content) {
+          if (!firstByteLogged) {
+            firstByteLogged = true;
+            logger.debug("llm.first_byte", {
+              cat: "llm",
+              provider: this.provider,
+              model: this.model,
+              ttft_ms: Date.now() - streamStartedAt
+            });
+          }
           text += delta.content;
           options.onChunk?.({ type: "text", text: delta.content });
         }
@@ -106,7 +143,19 @@ var OpenAIClient = class extends LLMClientBase {
             const existing = toolCallsMap.get(idx);
             if (tc.id) existing.id = tc.id;
             if (tc.function?.name) existing.name = tc.function.name;
-            if (tc.function?.arguments) existing.args += tc.function.arguments;
+            if (tc.function?.arguments) {
+              existing.args += tc.function.arguments;
+              if (existing.id) {
+                try {
+                  const parsed = JSON.parse(existing.args || "{}");
+                  options.onChunk?.({
+                    type: "tool_use_delta",
+                    toolCall: { id: existing.id, toolName: existing.name, args: parsed }
+                  });
+                } catch {
+                }
+              }
+            }
           }
         }
         if (chunk.choices[0]?.finish_reason) {
@@ -128,7 +177,13 @@ var OpenAIClient = class extends LLMClientBase {
         totalTokens: streamUsage?.total_tokens ?? 0
       };
       this.recordUsage(usage);
-      return { text, toolCalls, usage, stopReason: "stop" };
+      return {
+        text,
+        toolCalls,
+        usage,
+        stopReason: "stop",
+        ...reasoningContent ? { reasoningContent } : {}
+      };
     } catch (err) {
       this.handleApiError(err);
       throw err;
@@ -151,17 +206,27 @@ var OpenAIClient = class extends LLMClientBase {
         });
       }
     }
-    return { text, toolCalls, usage, stopReason: choice.finish_reason ?? void 0 };
+    const reasoningContent = extractReasoningContent(
+      choice.message
+    );
+    return {
+      text,
+      toolCalls,
+      usage,
+      stopReason: choice.finish_reason ?? void 0,
+      ...reasoningContent ? { reasoningContent } : {}
+    };
   }
   buildMessages(systemPrompt, messages) {
-    const result = [
-      { role: "system", content: systemPrompt }
-    ];
+    const result = [{ role: "system", content: systemPrompt }];
+    const needsReasoningBackfill = isDeepSeekThinkingModel(this.model);
     for (const msg of messages) {
       if (msg.role === "system") continue;
       if (msg.role === "assistant") {
+        const param = { role: "assistant" };
+        let reasoningContent;
         if (typeof msg.content === "string") {
-          result.push({ role: "assistant", content: msg.content });
+          param.content = msg.content;
         } else {
           const textParts = [];
           const toolCalls = [];
@@ -177,13 +242,23 @@ var OpenAIClient = class extends LLMClientBase {
                   arguments: JSON.stringify(block.input ?? {})
                 }
               });
+            } else if (block.type === "reasoning" && block.reasoningContent) {
+              reasoningContent = block.reasoningContent;
+            }
+            if (!reasoningContent && block.reasoningContent) {
+              reasoningContent = block.reasoningContent;
             }
           }
-          const param = { role: "assistant" };
           if (textParts.length) param.content = textParts.join("\n");
           if (toolCalls.length) param.tool_calls = toolCalls;
-          result.push(param);
         }
+        if (!reasoningContent && needsReasoningBackfill) {
+          reasoningContent = "";
+        }
+        if (reasoningContent !== void 0) {
+          param.reasoning_content = reasoningContent;
+        }
+        result.push(param);
       } else if (msg.role === "tool") {
         result.push({
           role: "tool",
@@ -252,6 +327,13 @@ var OpenAIClient = class extends LLMClientBase {
     throw err;
   }
 };
+function extractReasoningContent(msg) {
+  const candidate = msg.reasoning_content ?? msg.reasoning;
+  return typeof candidate === "string" && candidate.length > 0 ? candidate : void 0;
+}
+function isDeepSeekThinkingModel(model) {
+  return /^deepseek-v4(?:-|$)/i.test(model);
+}
 
 export {
   OpenAIClient

package/dist/{chunk-3EAEC566.cjs → chunk-M2QI5X3X.cjs}

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
 
 var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
 
@@ -7,16 +7,30 @@ _chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
 var _fs = require('fs');
 var _path = require('path');
 var _os = require('os');
-var MemoryManager = class {
+function resolveMemoryBaseDir(override) {
+  if (override) return override;
+  const fromEnv = process.env.CODE_SHELL_HOME;
+  if (fromEnv && fromEnv.length > 0) return fromEnv;
+  return _path.join.call(void 0, _os.homedir.call(void 0, ), ".code-shell");
+}
+var MemoryManager = (_class = class {
   
   
-  constructor(projectDir) {
-    const baseDir = _path.join.call(void 0, _os.homedir.call(void 0, ), ".code-shell");
-    if (projectDir) {
-      const projectHash = projectDir.replace(/[/\\:]/g, "-").replace(/^-/, "");
-      this.memoryDir = _path.join.call(void 0, baseDir, "projects", projectHash, "memory");
+  
+  // Per-instance cache of {fileName -> {name, description}} so the
+  // index can be rewritten without re-reading every memory file
+  // every time a single entry is saved/deleted (the previous code
+  // path called loadAll() on every save, giving O(N²) total I/O).
+  // null = "not initialized yet, fall back to disk on next access."
+  __init() {this.indexCache = null}
+  constructor(options) {;_class.prototype.__init.call(this);
+    const opts = typeof options === "string" ? { projectDir: options } : _nullishCoalesce(options, () => ( {}));
+    this.baseDir = resolveMemoryBaseDir(opts.baseDir);
+    if (opts.projectDir) {
+      const projectHash = opts.projectDir.replace(/[/\\:]/g, "-").replace(/^-/, "");
+      this.memoryDir = _path.join.call(void 0, this.baseDir, "projects", projectHash, "memory");
     } else {
-      this.memoryDir = _path.join.call(void 0, baseDir, "memory");
+      this.memoryDir = _path.join.call(void 0, this.baseDir, "memory");
     }
     this.indexPath = _path.join.call(void 0, this.memoryDir, "MEMORY.md");
     _fs.mkdirSync.call(void 0, this.memoryDir, { recursive: true });
@@ -39,7 +53,9 @@ type: ${entry.type}
 ${entry.content}
 `;
     _fs.writeFileSync.call(void 0, filePath, content, "utf-8");
-    this.updateIndex();
+    const cache = this.ensureIndexCache();
+    cache.set(fileName, { name: entry.name, description: entry.description });
+    this.writeIndex(cache);
     return fileName;
   }
   /**
@@ -88,7 +104,9 @@ ${entry.content}
     if (!entry) return false;
     try {
       _fs.unlinkSync.call(void 0, _path.join.call(void 0, this.memoryDir, entry.fileName));
-      this.updateIndex();
+      const cache = this.ensureIndexCache();
+      cache.delete(entry.fileName);
+      this.writeIndex(cache);
       return true;
     } catch (e3) {
       return false;
@@ -116,21 +134,36 @@ The following memories from previous sessions may be relevant:
 
 ` + lines.join("\n") + `
 
-To read a specific memory, check ~/.code-shell/memory/`;
+To read a specific memory, check ${this.memoryDir}/`;
   }
-  updateIndex() {
-    const entries = this.loadAll();
-    const lines = entries.map(
-      (e) => `- [${e.name}](${e.fileName}) \u2014 ${e.description}`
-    );
+  /**
+   * Lazy-build the in-memory index from disk on first use, then
+   * keep it in sync incrementally via save/delete. Avoids the
+   * O(N²) re-read of every memory file on every save.
+   */
+  ensureIndexCache() {
+    if (this.indexCache !== null) return this.indexCache;
+    const cache = /* @__PURE__ */ new Map();
+    for (const entry of this.loadAll()) {
+      cache.set(entry.fileName, { name: entry.name, description: entry.description });
+    }
+    this.indexCache = cache;
+    return cache;
+  }
+  writeIndex(cache) {
+    const lines = [];
+    for (const [fileName, meta] of cache) {
+      lines.push(`- [${meta.name}](${fileName}) \u2014 ${meta.description}`);
+    }
     const content = lines.length > 0 ? lines.join("\n") + "\n" : "(no memories stored)\n";
     _fs.writeFileSync.call(void 0, this.indexPath, content, "utf-8");
   }
   slugify(text) {
     return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
   }
-};
+}, _class);
+
 
 
 
-exports.MemoryManager = MemoryManager;
+exports.resolveMemoryBaseDir = resolveMemoryBaseDir; exports.MemoryManager = MemoryManager;

package/dist/{chunk-YZ25SSWJ.js → chunk-M2SVOKC6.js}

@@ -1,11 +1,14 @@
 import {
   LLMClientBase
-} from "./chunk-O6F2EF2Z.js";
+} from "./chunk-SCDKLTN3.js";
 import {
   ContextLimitError,
   LLMError,
   LLMRateLimitError
 } from "./chunk-FUOKLKR2.js";
+import {
+  logger
+} from "./chunk-ZRVPCXI7.js";
 import {
   init_esm_shims
 } from "./chunk-DI7RDLOS.js";
@@ -34,10 +37,28 @@ var AnthropicClient = class extends LLMClientBase {
     return this.withRetry(async () => {
       const messages = this.buildMessages(options.messages);
       const tools = options.tools ? this.convertTools(options.tools) : void 0;
-      if (options.stream && options.onChunk) {
-        return this.streamMessage(options, messages, tools);
+      const span = logger.span("llm.request", {
+        cat: "llm",
+        provider: this.provider,
+        model: this.model,
+        stream: !!(options.stream && options.onChunk),
+        messageCount: messages.length,
+        toolCount: tools?.length ?? 0
+      });
+      try {
+        const response = options.stream && options.onChunk ? await this.streamMessage(options, messages, tools) : await this.nonStreamMessage(options, messages, tools);
+        span.end({
+          stopReason: response.stopReason,
+          promptTokens: response.usage?.promptTokens,
+          completionTokens: response.usage?.completionTokens,
+          cacheReadTokens: response.usage?.cacheReadTokens,
+          cacheCreationTokens: response.usage?.cacheCreationTokens
+        });
+        return response;
+      } catch (err) {
+        span.fail(err);
+        throw err;
       }
-      return this.nonStreamMessage(options, messages, tools);
     });
   }
   async nonStreamMessage(options, messages, tools) {
@@ -96,7 +117,18 @@ var AnthropicClient = class extends LLMClientBase {
       let currentToolName = "";
       let currentToolId = "";
       let currentToolInput = "";
+      const streamStartedAt = Date.now();
+      let firstByteLogged = false;
       stream.on("text", (text) => {
+        if (!firstByteLogged) {
+          firstByteLogged = true;
+          logger.debug("llm.first_byte", {
+            cat: "llm",
+            provider: this.provider,
+            model: this.model,
+            ttft_ms: Date.now() - streamStartedAt
+          });
+        }
         currentText += text;
         options.onChunk?.({ type: "text", text });
       });
@@ -113,6 +145,16 @@ var AnthropicClient = class extends LLMClientBase {
       });
       stream.on("inputJson", (_delta, snapshot) => {
         currentToolInput = JSON.stringify(snapshot);
+        if (currentToolId) {
+          options.onChunk?.({
+            type: "tool_use_delta",
+            toolCall: {
+              id: currentToolId,
+              toolName: currentToolName,
+              args: snapshot ?? {}
+            }
+          });
+        }
       });
       const finalMessage = await stream.finalMessage();
       const usage = {