@ethosagent/core 0.4.2 → 0.4.3

package/dist/index.js

@@ -355,6 +355,7 @@ import { createHash } from "crypto";
 import { join, resolve, sep } from "path";
 
 // ../storage-fs/src/fs-storage.ts
+import { existsSync as fsExistsSync } from "fs";
 import {
   appendFile,
   chmod,
@@ -664,6 +665,26 @@ var DefaultContextEngineRegistry = class {
   }
 };
 
+// src/context-store.ts
+var ContextStore = class {
+  store = /* @__PURE__ */ new Map();
+  get(key) {
+    return this.store.get(key);
+  }
+  set(key, value) {
+    this.store.set(key, value);
+  }
+  clear() {
+    this.store.clear();
+  }
+  asContextMethods() {
+    return {
+      getContext: (key) => this.get(key),
+      setContext: (key, value) => this.set(key, value)
+    };
+  }
+};
+
 // src/defaults/in-memory-session.ts
 var InMemorySessionStore = class {
   sessions = /* @__PURE__ */ new Map();
@@ -972,6 +993,101 @@ var DefaultHookRegistry = class {
   }
 };
 
+// src/simple-completion.ts
+var SimpleCompletionImpl = class {
+  constructor(provider, defaultModel, onUsage) {
+    this.provider = provider;
+    this.defaultModel = defaultModel;
+    this.onUsage = onUsage;
+  }
+  provider;
+  defaultModel;
+  onUsage;
+  async complete(prompt, options) {
+    const model = options?.model ?? this.defaultModel;
+    let text = "";
+    let inputTokens = 0;
+    let outputTokens = 0;
+    const stream = this.provider.complete([{ role: "user", content: prompt }], [], {
+      system: options?.systemPrompt,
+      maxTokens: options?.maxTokens ?? 1024,
+      modelOverride: model !== this.provider.model ? model : void 0
+    });
+    for await (const chunk of stream) {
+      if (chunk.type === "text_delta") text += chunk.text;
+      if (chunk.type === "usage") {
+        inputTokens += chunk.usage.inputTokens;
+        outputTokens += chunk.usage.outputTokens;
+      }
+    }
+    this.onUsage({ input: inputTokens, output: outputTokens });
+    return text;
+  }
+};
+
+// src/capability-validator.ts
+function hostMatchesPattern(host, pattern) {
+  if (pattern === host) return true;
+  if (pattern === "*") return true;
+  if (pattern.startsWith("*.")) {
+    const suffix = pattern.slice(1);
+    return host.endsWith(suffix) && host.length > suffix.length;
+  }
+  return false;
+}
+function validateRegistration(tool, personality) {
+  const caps = tool.capabilities;
+  if (!caps) return [];
+  const errors = [];
+  if (caps.network) {
+    const allowed = personality.safety?.network?.allow;
+    if (allowed && allowed.length > 0) {
+      for (const host of caps.network.allowedHosts) {
+        if (host === "*") continue;
+        const covered = allowed.some((pattern) => hostMatchesPattern(host, pattern));
+        if (!covered) {
+          errors.push({
+            tool: tool.name,
+            capability: "network",
+            message: `host "${host}" is not in personality network allow list`
+          });
+        }
+      }
+    }
+  }
+  if (caps.fs_reach) {
+    const personalityRead = personality.fs_reach?.read ?? [];
+    const personalityWrite = personality.fs_reach?.write ?? [];
+    if (caps.fs_reach.read && caps.fs_reach.read !== "from-personality") {
+      for (const toolPath of caps.fs_reach.read) {
+        const covered = personalityRead.some((p) => toolPath === p || toolPath.startsWith(`${p}/`));
+        if (!covered) {
+          errors.push({
+            tool: tool.name,
+            capability: "fs_reach.read",
+            message: `path "${toolPath}" is not covered by personality fs_reach.read`
+          });
+        }
+      }
+    }
+    if (caps.fs_reach.write && caps.fs_reach.write !== "from-personality") {
+      for (const toolPath of caps.fs_reach.write) {
+        const covered = personalityWrite.some(
+          (p) => toolPath === p || toolPath.startsWith(`${p}/`)
+        );
+        if (!covered) {
+          errors.push({
+            tool: tool.name,
+            capability: "fs_reach.write",
+            message: `path "${toolPath}" is not covered by personality fs_reach.write`
+          });
+        }
+      }
+    }
+  }
+  return errors;
+}
+
 // src/scoped/scoped-attachments.ts
 var ScopedAttachmentsImpl = class {
   attachments;
@@ -1518,68 +1634,55 @@ function resolveCapabilities(toolName, capabilities, scopeIds, backends) {
   return result;
 }
 
-// src/capability-validator.ts
-function hostMatchesPattern(host, pattern) {
-  if (pattern === host) return true;
-  if (pattern === "*") return true;
-  if (pattern.startsWith("*.")) {
-    const suffix = pattern.slice(1);
-    return host.endsWith(suffix) && host.length > suffix.length;
-  }
-  return false;
-}
-function validateRegistration(tool, personality) {
-  const caps = tool.capabilities;
-  if (!caps) return [];
-  const errors = [];
-  if (caps.network) {
-    const allowed = personality.safety?.network?.allow;
-    if (allowed && allowed.length > 0) {
-      for (const host of caps.network.allowedHosts) {
-        if (host === "*") continue;
-        const covered = allowed.some((pattern) => hostMatchesPattern(host, pattern));
-        if (!covered) {
-          errors.push({
-            tool: tool.name,
-            capability: "network",
-            message: `host "${host}" is not in personality network allow list`
-          });
-        }
-      }
-    }
+// src/local-tool-transport.ts
+var LocalToolTransport = class {
+  constructor(lookup, backends, getLiveCtx) {
+    this.lookup = lookup;
+    this.backends = backends;
+    this.getLiveCtx = getLiveCtx;
   }
-  if (caps.fs_reach) {
-    const personalityRead = personality.fs_reach?.read ?? [];
-    const personalityWrite = personality.fs_reach?.write ?? [];
-    if (caps.fs_reach.read && caps.fs_reach.read !== "from-personality") {
-      for (const toolPath of caps.fs_reach.read) {
-        const covered = personalityRead.some((p) => toolPath === p || toolPath.startsWith(`${p}/`));
-        if (!covered) {
-          errors.push({
-            tool: tool.name,
-            capability: "fs_reach.read",
-            message: `path "${toolPath}" is not covered by personality fs_reach.read`
-          });
-        }
-      }
+  lookup;
+  backends;
+  getLiveCtx;
+  async execute(request, signal) {
+    const tool = this.lookup(request.name);
+    if (!tool) {
+      return { ok: false, error: `Tool '${request.name}' not found`, code: "not_available" };
     }
-    if (caps.fs_reach.write && caps.fs_reach.write !== "from-personality") {
-      for (const toolPath of caps.fs_reach.write) {
-        const covered = personalityWrite.some(
-          (p) => toolPath === p || toolPath.startsWith(`${p}/`)
-        );
-        if (!covered) {
-          errors.push({
-            tool: tool.name,
-            capability: "fs_reach.write",
-            message: `path "${toolPath}" is not covered by personality fs_reach.write`
-          });
-        }
-      }
+    const live = this.getLiveCtx?.();
+    const ctx = {
+      sessionId: request.sessionId,
+      sessionKey: request.sessionKey,
+      platform: request.platform,
+      workingDir: request.workingDir,
+      personalityId: request.personalityId,
+      teamId: request.teamId,
+      agentId: request.agentId,
+      memoryScopeId: request.memoryScopeId,
+      userScopeId: request.userScopeId,
+      currentTurn: request.currentTurn,
+      messageCount: request.messageCount,
+      resultBudgetChars: request.resultBudgetChars,
+      networkPolicy: request.networkPolicy,
+      dryRun: request.dryRun,
+      abortSignal: signal,
+      emit: live?.emit ?? (() => {
+      }),
+      readMtimes: live?.readMtimes,
+      storage: live?.storage
+    };
+    if (tool.capabilities && this.backends) {
+      const resolved = resolveCapabilities(
+        tool.name,
+        tool.capabilities,
+        { sessionId: request.sessionId, personalityId: request.personalityId },
+        { ...this.backends, inboundAttachments: live?.inboundAttachments }
+      );
+      Object.assign(ctx, resolved);
     }
+    return tool.execute(request.args, ctx);
   }
-  return errors;
-}
+};
 
 // src/tool-registry.ts
 function needsBackends(caps) {
@@ -1620,13 +1723,53 @@ function safeReduce(r, result, ctx) {
     return result;
   }
 }
+var DEFAULT_CACHE_TTL_MS = 3e5;
+var MAX_CACHE_ENTRIES = 1e3;
 var DefaultToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
+  resultCache = /* @__PURE__ */ new Map();
   backends;
   reducers;
-  constructor(backends, reducers) {
+  transport;
+  // Per-turn live context — updated by executeParallel before dispatching.
+  turnLiveCtx = { emit: () => {
+  } };
+  constructor(backends, reducers, transport) {
     this.backends = backends;
     this.reducers = reducers;
+    this.transport = transport ?? new LocalToolTransport(
+      (name) => this.tools.get(name)?.tool,
+      backends,
+      () => this.turnLiveCtx
+    );
+  }
+  cacheGet(tool, args, ctx) {
+    if (!tool.cache) return null;
+    const opts = tool.cache === true ? {} : tool.cache;
+    const keyPart = opts.keyFn ? opts.keyFn(args) : JSON.stringify(args);
+    const key = `${tool.name}:${ctx.sessionId}:${ctx.personalityId ?? ""}:${keyPart}`;
+    const entry = this.resultCache.get(key);
+    if (!entry) return null;
+    if (entry.expiresAt !== null && Date.now() > entry.expiresAt) {
+      this.resultCache.delete(key);
+      return null;
+    }
+    return entry.result;
+  }
+  cacheSet(tool, args, result, ctx) {
+    if (!tool.cache) return;
+    const opts = tool.cache === true ? {} : tool.cache;
+    const keyPart = opts.keyFn ? opts.keyFn(args) : JSON.stringify(args);
+    const key = `${tool.name}:${ctx.sessionId}:${ctx.personalityId ?? ""}:${keyPart}`;
+    const ttl = opts.ttlMs ?? DEFAULT_CACHE_TTL_MS;
+    const expiresAt = Date.now() + ttl;
+    this.resultCache.set(key, { result, expiresAt });
+    if (this.resultCache.size > MAX_CACHE_ENTRIES) {
+      const oldest = this.resultCache.keys().next().value;
+      if (oldest !== void 0) {
+        this.resultCache.delete(oldest);
+      }
+    }
   }
   register(tool, opts) {
     this.tools.set(tool.name, { tool, pluginId: opts?.pluginId });
@@ -1665,6 +1808,10 @@ var DefaultToolRegistry = class {
   getForToolset(toolset) {
     return this.getAvailable().filter((t) => t.toolset === toolset);
   }
+  /** v2.2 — Return the plugin id that registered a tool, if any. */
+  getPluginId(name) {
+    return this.tools.get(name)?.pluginId;
+  }
   toDefinitions(allowedTools, filterOpts) {
     const entries = [...this.tools.values()].filter(
       (e) => !e.tool.isAvailable || e.tool.isAvailable()
@@ -1717,8 +1864,34 @@ var DefaultToolRegistry = class {
   // Runs all tool calls in parallel. Results are returned in input order.
   // Budget is split evenly across parallel calls; each result is post-trimmed to budget.
   // allowedTools + filterOpts enforce tool access at execution time (belt-and-suspenders).
-  async executeParallel(calls, ctx, allowedTools, filterOpts, turnAttachments) {
+  async applyFilters(filters, tool, args, ctx, meta, execute) {
+    const matching = filters.filter(
+      (f) => (!f.toolName || (Array.isArray(f.toolName) ? f.toolName.includes(meta.toolName) : f.toolName === meta.toolName)) && (!f.toolset || tool.toolset === f.toolset)
+    );
+    let shortCircuit = null;
+    for (const f of matching) {
+      if (f.before) {
+        const r = await f.before(args, ctx, meta);
+        if (r !== null) {
+          shortCircuit = r;
+          break;
+        }
+      }
+    }
+    let result = shortCircuit ?? await execute();
+    for (const f of matching) {
+      if (f.after) result = await f.after(result, ctx, meta);
+    }
+    return result;
+  }
+  async executeParallel(calls, ctx, allowedTools, filterOpts, turnAttachments, filters) {
     const perCallBudget = Math.floor(ctx.resultBudgetChars / Math.max(calls.length, 1));
+    this.turnLiveCtx = {
+      emit: ctx.emit,
+      readMtimes: ctx.readMtimes,
+      storage: ctx.storage,
+      inboundAttachments: turnAttachments
+    };
     const results = await Promise.allSettled(
       calls.map(async (call) => {
         const entry = this.tools.get(call.name);
@@ -1767,6 +1940,10 @@ var DefaultToolRegistry = class {
             }
           };
         }
+        const cached = this.cacheGet(entry.tool, call.args, ctx);
+        if (cached) {
+          return { toolCallId: call.toolCallId, name: call.name, result: cached };
+        }
         if (needsBackends(entry.tool.capabilities) && !this.backends) {
           return {
             toolCallId: call.toolCallId,
@@ -1786,32 +1963,49 @@ var DefaultToolRegistry = class {
             result: synthesizeDryRunResult2(call.name, call.args)
           };
         }
-        const budget = Math.min(perCallBudget, entry.tool.maxResultChars ?? perCallBudget);
-        const toolCtx = { ...ctx, resultBudgetChars: budget };
+        const cappedBudget = Math.min(perCallBudget, entry.tool.maxResultChars ?? perCallBudget);
         try {
-          if (needsBackends(entry.tool.capabilities) && this.backends) {
-            const resolved = resolveCapabilities(
-              entry.tool.name,
-              entry.tool.capabilities,
-              { sessionId: ctx.sessionId, personalityId: ctx.personalityId },
-              { ...this.backends, inboundAttachments: turnAttachments }
-            );
-            Object.assign(toolCtx, resolved);
-          }
-          const rawResult = await entry.tool.execute(call.args, toolCtx);
+          const request = {
+            toolCallId: call.toolCallId,
+            name: call.name,
+            args: call.args,
+            sessionId: ctx.sessionId,
+            sessionKey: ctx.sessionKey,
+            platform: ctx.platform,
+            workingDir: ctx.workingDir,
+            personalityId: ctx.personalityId,
+            teamId: ctx.teamId,
+            agentId: ctx.agentId,
+            memoryScopeId: ctx.memoryScopeId,
+            userScopeId: ctx.userScopeId,
+            currentTurn: ctx.currentTurn,
+            messageCount: ctx.messageCount,
+            resultBudgetChars: cappedBudget,
+            networkPolicy: ctx.networkPolicy,
+            dryRun: ctx.dryRun
+          };
+          const rawResult = filters && filters.length > 0 ? await this.applyFilters(
+            filters,
+            entry.tool,
+            call.args,
+            ctx,
+            { toolName: call.name, toolCallId: call.toolCallId },
+            () => this.transport.execute(request, ctx.abortSignal)
+          ) : await this.transport.execute(request, ctx.abortSignal);
           const reducer = this.reducers?.get(call.name);
           const result = reducer ? safeReduce(reducer, rawResult, { args: call.args, turnCount: ctx.currentTurn ?? 0 }) : rawResult;
-          if (result.ok && result.value.length > budget) {
+          if (result.ok && result.value.length > cappedBudget) {
             return {
               toolCallId: call.toolCallId,
               name: call.name,
               result: {
                 ok: true,
-                value: `${result.value.slice(0, budget)}
+                value: `${result.value.slice(0, cappedBudget)}
 [truncated \u2014 ${result.value.length} chars total]`
               }
             };
           }
+          this.cacheSet(entry.tool, call.args, result, ctx);
           return { toolCallId: call.toolCallId, name: call.name, result };
         } catch (err) {
           return {
@@ -1854,7 +2048,12 @@ var KNOWN_AGENT_EVENT_TYPES = [
   "done",
   "context_meta",
   "run_start",
-  "dry_run_summary"
+  "dry_run_summary",
+  "tool_approval_required",
+  "tool_approval_response",
+  "evaluators_complete",
+  "credential_required",
+  "notification_received"
 ];
 function isKnownAgentEvent(event) {
   return KNOWN_AGENT_EVENT_TYPES.includes(event.type);
@@ -1896,10 +2095,16 @@ var AgentLoop = class {
   teamId;
   /** Per-personality MCP tool policy from mcp.yaml (NOT on PersonalityConfig). */
   mcpPolicy;
+  /** v2.2 — Callback to emit per-tool invocation metrics to the diagnostic store. */
+  onToolMetric;
+  /** v2.2 — Pre-turn credential check callback. */
+  credentialCheck;
   /** Per-session accumulated spend in USD. Keyed by sessionKey. Reset via resetSessionCost(). */
   sessionCosts = /* @__PURE__ */ new Map();
   /** FW-28 — per-session mtime registry. Keyed by sessionKey → (absPath → record). */
   sessionReadMtimes = /* @__PURE__ */ new Map();
+  /** v2: per-run key/value store threaded into ToolContext for plugin communication. */
+  contextStore = new ContextStore();
   constructor(config) {
     this.llm = config.llm;
     this.tools = config.tools ?? new DefaultToolRegistry();
@@ -1928,6 +2133,8 @@ var AgentLoop = class {
     if (config.clarifyBridge) this.clarifyBridge = config.clarifyBridge;
     if (config.requestDumpStore) this.requestDumpStore = config.requestDumpStore;
     if (config.mcpPolicy) this.mcpPolicy = config.mcpPolicy;
+    if (config.onToolMetric) this.onToolMetric = config.onToolMetric;
+    if (config.credentialCheck) this.credentialCheck = config.credentialCheck;
     this.contextEngines = config.contextEngines ?? new DefaultContextEngineRegistry();
   }
   /**
@@ -2061,6 +2268,26 @@ var AgentLoop = class {
       },
       allowedPlugins
     );
+    if (this.credentialCheck) {
+      const missing = await this.credentialCheck(sessionKey, text);
+      if (missing) {
+        if (traceId) this.observability?.endTrace(traceId, "error");
+        this.observability?.flush();
+        yield {
+          type: "credential_required",
+          pluginId: missing.pluginId,
+          credentialKey: missing.credentialKey,
+          kind: missing.kind,
+          label: missing.label,
+          description: missing.description,
+          authUrl: missing.authUrl,
+          sessionKey,
+          pendingUserMessage: text
+        };
+        yield { type: "done", text: "", turnCount: 0 };
+        return;
+      }
+    }
     const attachmentAnnotation = buildAttachmentAnnotation(opts.attachments ?? []);
     const annotatedText = attachmentAnnotation ? `${attachmentAnnotation}
 ${text}` : text;
@@ -2154,6 +2381,8 @@ ${text}` : text;
     if (promptCtx.meta && Object.keys(promptCtx.meta).length > 0) {
       yield { type: "context_meta", data: promptCtx.meta };
     }
+    const rawSkills = promptCtx.meta?.skillFilesUsed;
+    const activeSkillFiles = Array.isArray(rawSkills) && rawSkills.every((s) => typeof s === "string") ? rawSkills : void 0;
     if (memSnapshot && memSnapshot.entries.length > 0) {
       const blocks = [];
       const orderHints = {
@@ -2516,6 +2745,7 @@ ${rendered.slice(-MEMORY_MAX_CHARS)}`;
         sessionMtimes = /* @__PURE__ */ new Map();
         this.sessionReadMtimes.set(sessionKey, sessionMtimes);
       }
+      this.contextStore.clear();
       const toolCtxBase = {
         sessionId,
         sessionKey,
@@ -2541,7 +2771,12 @@ ${rendered.slice(-MEMORY_MAX_CHARS)}`;
         resultBudgetChars: this.resultBudgetChars,
         readMtimes: sessionMtimes,
         ...scopedStorage ? { storage: scopedStorage } : {},
-        ...personality.safety?.network ? { networkPolicy: personality.safety.network } : {}
+        ...personality.safety?.network ? { networkPolicy: personality.safety.network } : {},
+        ...this.contextStore.asContextMethods(),
+        llm: new SimpleCompletionImpl(this.llm, effectiveModel, ({ input, output }) => {
+          llmInputTokens += input;
+          llmOutputTokens += output;
+        })
       };
       const prepped = [];
       const spanIds = /* @__PURE__ */ new Map();
@@ -2659,6 +2894,15 @@ ${rendered.slice(-MEMORY_MAX_CHARS)}`;
           obsConfig
         });
         spanIds.set(tc.toolCallId, spanId ?? "");
+        const reqApprovalTool = this.tools.get(tc.toolName);
+        if (reqApprovalTool?.requiresApproval) {
+          yield {
+            type: "tool_approval_required",
+            toolCallId: tc.toolCallId,
+            toolName: tc.toolName,
+            args: effectiveArgs
+          };
+        }
         observe({ type: "tool_start", toolName: tc.toolName, args: effectiveArgs });
         yield {
           type: "tool_start",
@@ -2686,6 +2930,42 @@ ${rendered.slice(-MEMORY_MAX_CHARS)}`;
         opts.attachments
       ) : [];
       const execResultMap = new Map(execResults.map((r) => [r.toolCallId, r]));
+      const directResult = execResults.find((r) => {
+        const t = this.tools.get(r.name);
+        return r.result.ok && t?.returnDirect;
+      });
+      if (directResult?.result.ok) {
+        for (const p of prepped) {
+          const execResult = execResultMap.get(p.toolCallId);
+          const result = p.rejected ? { ok: false, error: p.rejected, code: "execution_failed" } : execResult?.result ?? {
+            ok: false,
+            error: "Tool result missing",
+            code: "execution_failed"
+          };
+          await this.session.appendMessage({
+            sessionId,
+            role: "tool_result",
+            content: result.ok ? result.value : result.error,
+            toolCallId: p.toolCallId,
+            toolName: p.name
+          });
+        }
+        for (const r of execResults) {
+          yield {
+            type: "tool_end",
+            toolCallId: r.toolCallId,
+            toolName: r.name,
+            ok: r.result.ok,
+            durationMs: Date.now() - startedAt,
+            result: r.result.ok ? r.result.value : r.result.error
+          };
+        }
+        fullText = directResult.result.value;
+        if (traceId) this.observability?.endTrace(traceId, "ok");
+        this.observability?.flush();
+        yield { type: "done", text: fullText, turnCount };
+        return;
+      }
       if (opts.dryRun) {
         for (const input of execInputs) {
           dryRunPlan.push({
@@ -2768,6 +3048,19 @@ ${rendered.slice(-MEMORY_MAX_CHARS)}`;
             },
             allowedPlugins
           );
+          if (this.onToolMetric) {
+            const pluginId = this.tools.getPluginId?.(p.name);
+            if (pluginId) {
+              this.onToolMetric({
+                pluginId,
+                toolName: p.name,
+                ok: result.ok,
+                durationMs,
+                sessionId,
+                turnId: String(turnCount)
+              });
+            }
+          }
           const touchedPath = extractFilePath(p.args);
           if (touchedPath !== void 0) {
             await this.hooks.fireVoid(
@@ -2853,7 +3146,8 @@ ${rendered.slice(-MEMORY_MAX_CHARS)}`;
         successfulToolCalls,
         totalToolCalls,
         toolNames: [...toolNameCounts.keys()],
-        initialPrompt: text
+        initialPrompt: text,
+        activeSkillFiles
       },
       allowedPlugins
     );
@@ -3658,6 +3952,27 @@ var LastWriteWinsPolicy = class {
   }
 };
 
+// src/notification-router.ts
+var DefaultNotificationRouter = class {
+  adapters = /* @__PURE__ */ new Map();
+  async route(pluginId, opts) {
+    if (opts.sessionKey === "*") return;
+    const adapter = this.adapters.get(opts.sessionKey);
+    if (!adapter) return;
+    if (opts.startTurn) {
+      await adapter.injectUserMessage(opts.message);
+    } else {
+      await adapter.send(opts.message, opts.payload);
+    }
+  }
+  register(sessionKey, adapter) {
+    this.adapters.set(sessionKey, adapter);
+  }
+  deregister(sessionKey) {
+    this.adapters.delete(sessionKey);
+  }
+};
+
 // src/path-boundary.ts
 import { resolve as resolve5, sep as sep2 } from "path";
 function assertWithinBase(base, target) {
@@ -4056,10 +4371,12 @@ export {
   ClarifyBusyError,
   ClarifyNoSurfaceError,
   ClarifyTimedOutNoDefaultError,
+  ContextStore,
   DefaultContextEngineRegistry,
   DefaultHookRegistry,
   DefaultLLMProviderRegistry,
   DefaultMemoryProviderRegistry,
+  DefaultNotificationRouter,
   DefaultPersonalityRegistry,
   DefaultToolRegistry,
   DefaultToolResultReducerRegistry,
@@ -4071,6 +4388,7 @@ export {
   KNOWN_AGENT_EVENT_TYPES,
   LastWriteWinsPolicy,
   LazyOnDemandPolicy,
+  LocalToolTransport,
   MemoryConflictError2 as MemoryConflictError,
   NoopMemoryProvider,
   PluginRegistry,
@@ -4080,6 +4398,7 @@ export {
   ScopedProcessImpl,
   ScopedSecretsImpl,
   SemanticSummaryEngine,
+  SimpleCompletionImpl,
   SsrfError,
   applyTemporalDecay,
   assertWithinBase,