@opencode/codemode 0.0.0-dev-19678 → 0.0.0-dev-19682

package/dist/codemode.js

@@ -71,7 +71,9 @@ export const make = (options = {}) => {
         }
     }
     return {
-        catalog: prepared.catalog,
+        get catalog() {
+            return prepared.catalog;
+        },
         execute: (code) => executeProgram(code, prepared, limits, options.hooks ?? {}, (ctx) => extensionGlobals(ctx, extensions)),
     };
 };

package/dist/tool-runtime.d.ts

@@ -58,7 +58,7 @@ type ToolNode<R> = {
     namespace?: Namespace<R>;
     readonly children: Map<string, ToolNode<R>>;
 };
-/** Tools indexed once per runtime: the lookup trie plus the model-facing catalog and search index. */
+/** Tools indexed once per runtime, with discovery materialized on demand. */
 export type Prepared<R = never> = {
     readonly root: ToolNode<R>;
     readonly catalog: ReadonlyArray<ToolDescription>;

package/dist/tool-runtime.js

@@ -80,13 +80,22 @@ const flattenTools = (node, path = [], namespaces = []) => {
         ...Array.from(node.children).flatMap(([name, child]) => flattenTools(child, [...path, name], next)),
     ];
 };
-const describeTool = (visible) => ({
-    path: visible.path,
-    description: visible.tool.description,
-    signature: isEmptyInput(visible.tool)
-        ? `${toolExpression(visible.path)}(): Promise<${outputTypeScript(visible.tool, true)}>`
-        : `${toolExpression(visible.path)}(input: ${inputTypeScript(visible.tool, true)}): Promise<${outputTypeScript(visible.tool, true)}>`,
-});
+const describeTool = (visible) => {
+    let signature;
+    return {
+        path: visible.path,
+        description: visible.tool.description,
+        get signature() {
+            // Search ranks paths and descriptions first; only returned matches need their schemas rendered.
+            // Joining the final fragments avoids retaining the rendering's intermediate string ropes in JSC.
+            return (signature ??= [
+                toolExpression(visible.path),
+                isEmptyInput(visible.tool) ? "()" : `(input: ${inputTypeScript(visible.tool, true)})`,
+                `: Promise<${outputTypeScript(visible.tool, true)}>`,
+            ].join(""));
+        },
+    };
+};
 const tokenize = (query) => query
     .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
     .toLowerCase()
@@ -165,12 +174,20 @@ const toSearchEntry = (visible) => ({
 });
 export const prepare = (tools) => {
     const root = toolTrie(tools);
-    // Discovery bytes are durable instructions, so order only after canonical-path collisions settle.
-    const visible = flattenTools(root).sort((left, right) => compareText(left.path, right.path));
+    let searchIndex;
+    let catalog;
     return {
         root,
-        catalog: visible.map(describeTool),
-        searchIndex: visible.map(toSearchEntry),
+        get catalog() {
+            return (catalog ??= this.searchIndex.map((entry) => entry.description));
+        },
+        get searchIndex() {
+            // Executing known tools only needs the trie. Render discovery when it is actually read,
+            // ordering after canonical-path collisions settle so instruction bytes stay deterministic.
+            return (searchIndex ??= flattenTools(root)
+                .sort((left, right) => compareText(left.path, right.path))
+                .map(toSearchEntry));
+        },
     };
 };
 const lookup = (root, segments) => segments.reduce((node, segment) => node?.children.get(segment), root);
@@ -209,7 +226,6 @@ export class ToolRuntimeError extends Error {
 export const make = (prepared, maxToolCalls, hooks = {}) => {
     const calls = [];
     const root = prepared.root;
-    const searchTool = makeSearchTool(prepared.searchIndex);
     const recordCall = (call) => {
         if (maxToolCalls !== undefined && calls.length >= maxToolCalls) {
             throw new ToolRuntimeError("ToolCallLimitExceeded", `Execution exceeded its tool-call limit of ${maxToolCalls}.`);
@@ -247,12 +263,12 @@ export const make = (prepared, maxToolCalls, hooks = {}) => {
         calls,
         hooks,
         keys: (path) => namespaceKeys(root, path),
-        search: (args) => Effect.suspend(() => executeTool("search", searchTool, args)),
+        search: (args) => Effect.suspend(() => executeTool("search", makeSearchTool(prepared.searchIndex), args)),
         execute: (path, args) => Effect.suspend(() => {
             const segments = canonicalSegments(path);
             // Models often write `tools.search(...)` for the bare `search(...)`; honor it unless a tool owns that path.
             if (segments.length === 1 && segments[0] === "search" && lookup(root, segments) === undefined)
-                return executeTool("search", searchTool, args);
+                return executeTool("search", makeSearchTool(prepared.searchIndex), args);
             return executeTool(segments.join("."), resolve(root, path), args);
         }),
     };

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/codemode",
-  "version": "0.0.0-dev-19678",
+  "version": "0.0.0-dev-19682",
   "description": "Effect-native confined code execution over schema-described tools",
   "type": "module",
   "license": "MIT",