thinkwell 0.5.5 → 0.5.7

package/dist/think-builder.js

@@ -1,386 +1,305 @@
 import { readFile } from "node:fs/promises";
 import { dirname } from "node:path";
-import { mcpServer, createSkillServer, parseSkillMd, validateSkillName, validateSkillDescription, } from "@thinkwell/acp";
+import { features } from "./generated/features.js";
+import { mcpServer, createSkillServer, parseSkillMd, validateSkillName, validateSkillDescription } from "@thinkwell/acp";
 import { ThoughtStream } from "./thought-stream.js";
-/**
- * Internal session handler for ThinkBuilder
- */
 class ThinkSession {
-    sessionId;
-    _conn;
-    _pendingUpdates = [];
-    _updateResolvers = [];
-    _closed = false;
-    constructor(sessionId, conn) {
-        this.sessionId = sessionId;
-        this._conn = conn;
-    }
-    async sendPrompt(content) {
-        const response = await this._conn.connection.prompt({
-            sessionId: this.sessionId,
-            prompt: [{ type: "text", text: content }],
-        });
-        if (response.stopReason) {
-            this._pushInternal({ type: "stop", reason: response.stopReason });
-        }
-    }
-    pushUpdate(update) {
-        this._pushInternal(update);
-    }
-    _pushInternal(update) {
-        if (this._updateResolvers.length > 0) {
-            const resolver = this._updateResolvers.shift();
-            resolver(update);
-        }
-        else {
-            this._pendingUpdates.push(update);
-        }
-    }
-    async readUpdate() {
-        if (this._pendingUpdates.length > 0) {
-            return this._pendingUpdates.shift();
-        }
-        if (this._closed) {
-            return { type: "stop", reason: "session_closed" };
-        }
-        return new Promise((resolve) => {
-            this._updateResolvers.push(resolve);
-        });
-    }
-    close() {
-        this._closed = true;
-        for (const resolver of this._updateResolvers) {
-            resolver({ type: "stop", reason: "session_closed" });
-        }
-        this._updateResolvers = [];
-    }
+  sessionId;
+  _conn;
+  _pendingUpdates = [];
+  _updateResolvers = [];
+  _closed = !1;
+  constructor(sessionId, conn) {
+    this.sessionId = sessionId, this._conn = conn;
+  }
+  async sendPrompt(content) {
+    const response = await this._conn.connection.prompt({
+      sessionId: this.sessionId,
+      prompt: [{ type: "text", text: content }]
+    });
+    response.stopReason && this._pushInternal({ type: "stop", reason: response.stopReason });
+  }
+  pushUpdate(update) {
+    this._pushInternal(update);
+  }
+  _pushInternal(update) {
+    this._updateResolvers.length > 0 ? this._updateResolvers.shift()(update) : this._pendingUpdates.push(update);
+  }
+  async readUpdate() {
+    return this._pendingUpdates.length > 0 ? this._pendingUpdates.shift() : this._closed ? { type: "stop", reason: "session_closed" } : new Promise((resolve) => {
+      this._updateResolvers.push(resolve);
+    });
+  }
+  close() {
+    this._closed = !0;
+    for (const resolver of this._updateResolvers)
+      resolver({ type: "stop", reason: "session_closed" });
+    this._updateResolvers = [];
+  }
 }
 class PlanImpl {
-    _conn;
-    _promptParts;
-    _tools;
-    _skills;
-    _schemaProvider;
-    _cwd;
-    _existingSessionId;
-    constructor(state) {
-        this._conn = state.conn;
-        this._promptParts = state.promptParts;
-        this._tools = state.tools;
-        this._skills = state.skills;
-        this._schemaProvider = state.schemaProvider;
-        this._cwd = state.cwd;
-        this._existingSessionId = state.existingSessionId;
-    }
-    _clone(overrides) {
-        return new PlanImpl({
-            conn: this._conn,
-            promptParts: this._promptParts,
-            tools: this._tools,
-            skills: this._skills,
-            schemaProvider: this._schemaProvider,
-            cwd: this._cwd,
-            existingSessionId: this._existingSessionId,
-            ...overrides,
-        });
-    }
-    text(content) {
-        return this._clone({ promptParts: [...this._promptParts, content] });
-    }
-    textln(content) {
-        return this._clone({ promptParts: [...this._promptParts, content + "\n"] });
-    }
-    quote(content, tag = "quote") {
-        const part = !content.includes("\n")
-            ? `<${tag}>${content}</${tag}>\n`
-            : `<${tag}>\n${content}\n</${tag}>\n`;
-        return this._clone({ promptParts: [...this._promptParts, part] });
-    }
-    code(content, language = "") {
-        return this._clone({
-            promptParts: [...this._promptParts, `\`\`\`${language}\n${content}\n\`\`\`\n`],
-        });
-    }
-    tool(name, description, inputSchemaOrHandler, outputSchemaOrHandler, handler) {
-        let inputSchema;
-        let outputSchema;
-        let actualHandler;
-        if (typeof inputSchemaOrHandler === "function") {
-            inputSchema = { toJsonSchema: () => ({ type: "object" }) };
-            outputSchema = { toJsonSchema: () => ({ type: "object" }) };
-            actualHandler = inputSchemaOrHandler;
-        }
-        else if (typeof outputSchemaOrHandler === "function") {
-            inputSchema = inputSchemaOrHandler;
-            outputSchema = { toJsonSchema: () => ({ type: "object" }) };
-            actualHandler = outputSchemaOrHandler;
-        }
-        else {
-            inputSchema = inputSchemaOrHandler;
-            outputSchema = outputSchemaOrHandler;
-            actualHandler = handler;
-        }
-        const newTools = new Map(this._tools);
-        newTools.set(name, {
-            name,
-            description,
-            handler: actualHandler,
-            inputSchema,
-            outputSchema,
-            includeInPrompt: true,
-        });
-        return this._clone({ tools: newTools });
-    }
-    defineTool(name, description, inputSchemaOrHandler, outputSchemaOrHandler, handler) {
-        let inputSchema;
-        let outputSchema;
-        let actualHandler;
-        if (typeof inputSchemaOrHandler === "function") {
-            inputSchema = { toJsonSchema: () => ({ type: "object" }) };
-            outputSchema = { toJsonSchema: () => ({ type: "object" }) };
-            actualHandler = inputSchemaOrHandler;
-        }
-        else if (typeof outputSchemaOrHandler === "function") {
-            inputSchema = inputSchemaOrHandler;
-            outputSchema = { toJsonSchema: () => ({ type: "object" }) };
-            actualHandler = outputSchemaOrHandler;
-        }
-        else {
-            inputSchema = inputSchemaOrHandler;
-            outputSchema = outputSchemaOrHandler;
-            actualHandler = handler;
-        }
-        const newTools = new Map(this._tools);
-        newTools.set(name, {
-            name,
-            description,
-            handler: actualHandler,
-            inputSchema,
-            outputSchema,
-            includeInPrompt: false,
-        });
-        return this._clone({ tools: newTools });
-    }
-    skill(pathOrDef) {
-        if (typeof pathOrDef === "string") {
-            return this._clone({ skills: [...this._skills, { type: "stored", path: pathOrDef }] });
-        }
-        else {
-            validateSkillName(pathOrDef.name);
-            validateSkillDescription(pathOrDef.description);
-            return this._clone({
-                skills: [...this._skills, {
-                        type: "virtual",
-                        skill: {
-                            name: pathOrDef.name,
-                            description: pathOrDef.description,
-                            body: pathOrDef.body,
-                            tools: pathOrDef.tools,
-                        },
-                    }],
-            });
-        }
-    }
-    cwd(path) {
-        return this._clone({ cwd: path });
-    }
-    async _resolveSkills() {
-        const resolved = [];
-        for (const deferred of this._skills) {
-            if (deferred.type === "virtual") {
-                resolved.push(deferred.skill);
-            }
-            else {
-                const content = await readFile(deferred.path, "utf-8");
-                const parsed = parseSkillMd(content);
-                const stored = {
-                    name: parsed.name,
-                    description: parsed.description,
-                    body: parsed.body,
-                    basePath: dirname(deferred.path),
-                };
-                resolved.push(stored);
-            }
-        }
-        return resolved;
-    }
-    _buildSkillsPrompt(skills) {
-        if (skills.length === 0)
-            return "";
-        let xml = "<available_skills>\n";
-        for (const skill of skills) {
-            xml += `  <skill>\n`;
-            xml += `    <name>${skill.name}</name>\n`;
-            xml += `    <description>${skill.description}</description>\n`;
-            xml += `  </skill>\n`;
+  _conn;
+  _promptParts;
+  _tools;
+  _skills;
+  _schemaProvider;
+  _cwd;
+  _existingSessionId;
+  constructor(state) {
+    this._conn = state.conn, this._promptParts = state.promptParts, this._tools = state.tools, this._skills = state.skills, this._schemaProvider = state.schemaProvider, this._cwd = state.cwd, this._existingSessionId = state.existingSessionId;
+  }
+  _clone(overrides) {
+    return new PlanImpl({
+      conn: this._conn,
+      promptParts: this._promptParts,
+      tools: this._tools,
+      skills: this._skills,
+      schemaProvider: this._schemaProvider,
+      cwd: this._cwd,
+      existingSessionId: this._existingSessionId,
+      ...overrides
+    });
+  }
+  text(content) {
+    return this._clone({ promptParts: [...this._promptParts, content] });
+  }
+  textln(content) {
+    return this._clone({ promptParts: [...this._promptParts, content + `
+`] });
+  }
+  quote(content, tag = "quote") {
+    const part = content.includes(`
+`) ? `<${tag}>
+${content}
+</${tag}>
+` : `<${tag}>${content}</${tag}>
+`;
+    return this._clone({ promptParts: [...this._promptParts, part] });
+  }
+  code(content, language = "") {
+    return this._clone({
+      promptParts: [...this._promptParts, `\`\`\`${language}
+${content}
+\`\`\`
+`]
+    });
+  }
+  tool(name, description, inputSchemaOrHandler, outputSchemaOrHandler, handler) {
+    let inputSchema, outputSchema, actualHandler;
+    typeof inputSchemaOrHandler == "function" ? (inputSchema = { toJsonSchema: () => ({ type: "object" }) }, outputSchema = { toJsonSchema: () => ({ type: "object" }) }, actualHandler = inputSchemaOrHandler) : typeof outputSchemaOrHandler == "function" ? (inputSchema = inputSchemaOrHandler, outputSchema = { toJsonSchema: () => ({ type: "object" }) }, actualHandler = outputSchemaOrHandler) : (inputSchema = inputSchemaOrHandler, outputSchema = outputSchemaOrHandler, actualHandler = handler);
+    const newTools = new Map(this._tools);
+    return newTools.set(name, {
+      name,
+      description,
+      handler: actualHandler,
+      inputSchema,
+      outputSchema,
+      includeInPrompt: !0
+    }), this._clone({ tools: newTools });
+  }
+  defineTool(name, description, inputSchemaOrHandler, outputSchemaOrHandler, handler) {
+    let inputSchema, outputSchema, actualHandler;
+    typeof inputSchemaOrHandler == "function" ? (inputSchema = { toJsonSchema: () => ({ type: "object" }) }, outputSchema = { toJsonSchema: () => ({ type: "object" }) }, actualHandler = inputSchemaOrHandler) : typeof outputSchemaOrHandler == "function" ? (inputSchema = inputSchemaOrHandler, outputSchema = { toJsonSchema: () => ({ type: "object" }) }, actualHandler = outputSchemaOrHandler) : (inputSchema = inputSchemaOrHandler, outputSchema = outputSchemaOrHandler, actualHandler = handler);
+    const newTools = new Map(this._tools);
+    return newTools.set(name, {
+      name,
+      description,
+      handler: actualHandler,
+      inputSchema,
+      outputSchema,
+      includeInPrompt: !1
+    }), this._clone({ tools: newTools });
+  }
+  skill(pathOrDef) {
+    return typeof pathOrDef == "string" ? this._clone({ skills: [...this._skills, { type: "stored", path: pathOrDef }] }) : (validateSkillName(pathOrDef.name), validateSkillDescription(pathOrDef.description), this._clone({
+      skills: [...this._skills, {
+        type: "virtual",
+        skill: {
+          name: pathOrDef.name,
+          description: pathOrDef.description,
+          body: pathOrDef.body,
+          tools: pathOrDef.tools
         }
-        xml += "</available_skills>\n";
-        xml += "\n";
-        xml += "The above skills are available to you. When a task matches a skill's description,\n";
-        xml += "call the `activate_skill` tool with the skill name to load its full instructions.\n";
-        xml += "If the skill provides tools, use `call_skill_tool` to invoke them.\n";
-        xml += "If the skill references files, use `read_skill_file` to access them.\n";
-        return xml + "\n";
+      }]
+    }));
+  }
+  cwd(path) {
+    return this._clone({ cwd: path });
+  }
+  async _resolveSkills() {
+    const resolved = [];
+    for (const deferred of this._skills)
+      if (deferred.type === "virtual")
+        resolved.push(deferred.skill);
+      else {
+        const content = await readFile(deferred.path, "utf-8"), parsed = parseSkillMd(content), stored = {
+          name: parsed.name,
+          description: parsed.description,
+          body: parsed.body,
+          basePath: dirname(deferred.path)
+        };
+        resolved.push(stored);
+      }
+    return resolved;
+  }
+  _buildSkillsPrompt(skills) {
+    if (skills.length === 0)
+      return "";
+    let xml = `<available_skills>
+`;
+    for (const skill of skills)
+      xml += `  <skill>
+`, xml += `    <name>${skill.name}</name>
+`, xml += `    <description>${skill.description}</description>
+`, xml += `  </skill>
+`;
+    return xml += `</available_skills>
+`, xml += `
+`, xml += `The above skills are available to you. When a task matches a skill's description,
+`, xml += "call the `activate_skill` tool with the skill name to load its full instructions.\n", xml += "If the skill provides tools, use `call_skill_tool` to invoke them.\n", xml += "If the skill references files, use `read_skill_file` to access them.\n", xml + `
+`;
+  }
+  async run() {
+    return this.stream().result;
+  }
+  stream() {
+    const stream = new ThoughtStream();
+    return this._executeStream(stream).catch((err) => {
+      stream.rejectResult(err instanceof Error ? err : new Error(String(err?.message ?? err))), stream.close();
+    }), stream;
+  }
+  async _executeStream(stream) {
+    this._conn.initialized || (await this._conn.connection.initialize({
+      protocolVersion: 1,
+      clientCapabilities: {}
+    }), this._conn.initialized = !0);
+    const resolvedSkills = await this._resolveSkills();
+    let prompt = this._buildSkillsPrompt(resolvedSkills) + this._promptParts.join("");
+    const toolsWithPrompt = Array.from(this._tools.values()).filter((t) => t.includeInPrompt);
+    if (toolsWithPrompt.length > 0) {
+      prompt += `
+
+Available tools:
+`;
+      for (const tool of toolsWithPrompt)
+        prompt += `- ${tool.name}: ${tool.description}
+`;
     }
-    async run() {
-        return this.stream().result;
-    }
-    stream() {
-        const stream = new ThoughtStream();
-        this._executeStream(stream).catch((err) => {
-            stream.rejectResult(err instanceof Error ? err : new Error(String(err?.message ?? err)));
-            stream.close();
-        });
-        return stream;
-    }
-    async _executeStream(stream) {
-        // Ensure initialized
-        if (!this._conn.initialized) {
-            await this._conn.connection.initialize({
-                protocolVersion: 1,
-                clientCapabilities: {},
-            });
-            this._conn.initialized = true;
+    const serverBuilder = mcpServer("thinkwell");
+    let resultReceived = !1, result, resultError, resolveResultReady;
+    const resultReady = new Promise((r) => {
+      resolveResultReady = r;
+    }), rawSchema = this._schemaProvider?.toJsonSchema() ?? { type: "object" }, needsWrap = rawSchema.type !== "object", outputSchema = needsWrap ? { type: "object", properties: { result: rawSchema }, required: ["result"] } : rawSchema, acceptResult = (input) => {
+      if (resultReceived)
+        return;
+      const value = needsWrap ? input.result : input, schemaRequired = rawSchema.required;
+      let required = Array.isArray(schemaRequired) ? schemaRequired : void 0;
+      if (features.FAULT_INJECTION) {
+        const injectedField = process.env.THINKWELL_INJECT_REQUIRED_FIELD;
+        injectedField && (required = required ? [...required, injectedField] : [injectedField]);
+      }
+      if (Array.isArray(required)) {
+        if (value == null || typeof value != "object") {
+          resultError = new TypeError(`Agent result must be an object when schema has required fields, got ${value === null ? "null" : typeof value}`), resultReceived = !0, resolveResultReady();
+          return;
         }
-        // Resolve deferred skills
-        const resolvedSkills = await this._resolveSkills();
-        // Build the prompt: skills block first, then user prompt parts
-        let prompt = this._buildSkillsPrompt(resolvedSkills) + this._promptParts.join("");
-        // Add tool references to the prompt
-        const toolsWithPrompt = Array.from(this._tools.values()).filter((t) => t.includeInPrompt);
-        if (toolsWithPrompt.length > 0) {
-            prompt += "\n\nAvailable tools:\n";
-            for (const tool of toolsWithPrompt) {
-                prompt += `- ${tool.name}: ${tool.description}\n`;
-            }
+        const obj = value, missing = required.filter((key) => !Object.hasOwn(obj, key));
+        if (missing.length > 0) {
+          resultError = new TypeError(`Agent result is missing required field(s): ${missing.join(", ")}`), resultReceived = !0, resolveResultReady();
+          return;
         }
-        // Create the MCP server builder
-        const serverBuilder = mcpServer("thinkwell");
-        // Track if we've received a result
-        let resultReceived = false;
-        let result;
-        // Get the output schema for the return_result tool.
-        // The Anthropic API requires tool input schemas to have type: "object" at
-        // the root. Union types (anyOf/oneOf) don't satisfy this, so we wrap them
-        // in a single-property object and unwrap in the handler.
-        const rawSchema = this._schemaProvider?.toJsonSchema() ?? { type: "object" };
-        const needsWrap = rawSchema.type !== "object";
-        const outputSchema = needsWrap
-            ? { type: "object", properties: { result: rawSchema }, required: ["result"] }
-            : rawSchema;
-        // Add return instruction
-        prompt += "\n\nWhen you have your answer, call the `return_result` MCP tool with the result.";
-        // Add the return_result tool
-        serverBuilder.tool("return_result", "Return the final result", outputSchema, { type: "object", properties: { success: { type: "boolean" } } }, async (input) => {
-            result = (needsWrap ? input.result : input);
-            resultReceived = true;
-            return { success: true };
+      }
+      result = value, resultReceived = !0, resolveResultReady();
+    };
+    prompt += "\n\nWhen you have your answer, call the `return_result` MCP tool with the result.", serverBuilder.tool("return_result", "Return the final result", outputSchema, { type: "object", properties: { success: { type: "boolean" } } }, async (input) => (acceptResult(input), { success: !0 }));
+    for (const tool of this._tools.values())
+      serverBuilder.tool(tool.name, tool.description, tool.inputSchema.toJsonSchema(), tool.outputSchema.toJsonSchema(), async (input, _context) => tool.handler(input));
+    const server = serverBuilder.build(), skillServer = resolvedSkills.length > 0 ? createSkillServer(resolvedSkills) : void 0;
+    this._conn.mcpHandler.register(server), skillServer && this._conn.mcpHandler.register(skillServer), this._conn.mcpHandler.setSessionId(this._existingSessionId ?? "pending");
+    try {
+      let sessionId;
+      if (this._existingSessionId)
+        sessionId = this._existingSessionId;
+      else {
+        const mcpServers = [{
+          type: "http",
+          name: server.name,
+          url: server.acpUrl,
+          headers: []
+        }];
+        skillServer && mcpServers.push({
+          type: "http",
+          name: skillServer.name,
+          url: skillServer.acpUrl,
+          headers: []
         });
-        // Add all registered tools
-        for (const tool of this._tools.values()) {
-            serverBuilder.tool(tool.name, tool.description, tool.inputSchema.toJsonSchema(), tool.outputSchema.toJsonSchema(), async (input, _context) => {
-                return tool.handler(input);
-            });
-        }
-        const server = serverBuilder.build();
-        // Build skill MCP server if skills are present
-        const skillServer = resolvedSkills.length > 0
-            ? createSkillServer(resolvedSkills)
-            : undefined;
-        // Register the MCP server(s)
-        this._conn.mcpHandler.register(server);
-        if (skillServer) {
-            this._conn.mcpHandler.register(skillServer);
-        }
-        this._conn.mcpHandler.setSessionId(this._existingSessionId ?? "pending");
-        try {
-            // Create or reuse session
-            let sessionId;
-            if (this._existingSessionId) {
-                // Reuse existing session
-                sessionId = this._existingSessionId;
-            }
-            else {
-                // Create new ephemeral session
-                const mcpServers = [{
-                        type: "http",
-                        name: server.name,
-                        url: server.acpUrl,
-                        headers: [],
-                    }];
-                if (skillServer) {
-                    mcpServers.push({
-                        type: "http",
-                        name: skillServer.name,
-                        url: skillServer.acpUrl,
-                        headers: [],
-                    });
-                }
-                const request = {
-                    cwd: this._cwd ?? process.cwd(),
-                    mcpServers,
-                };
-                const response = await this._conn.connection.newSession(request);
-                sessionId = response.sessionId;
+        const request = {
+          cwd: this._cwd ?? process.cwd(),
+          mcpServers
+        };
+        sessionId = (await this._conn.connection.newSession(request)).sessionId;
+      }
+      this._conn.mcpHandler.setSessionId(sessionId);
+      const session = new ThinkSession(sessionId, this._conn);
+      this._conn.sessionHandlers.set(sessionId, session), await this._conn.mcpHandler.waitForToolsDiscovery(sessionId, 2e3);
+      try {
+        const pendingToolCalls = [], sendTurn = async (text) => {
+          const promptPromise = session.sendPrompt(text);
+          for (; !resultReceived; ) {
+            const update = await session.readUpdate();
+            if (update.type === "stop")
+              break;
+            if (update.type === "tool_start") {
+              const toolName = update.title;
+              (this._tools.has(toolName) || toolName === "return_result") && pendingToolCalls.push({ id: update.id, name: toolName, input: update.input });
             }
-            // Update MCP handler with actual session ID
-            this._conn.mcpHandler.setSessionId(sessionId);
-            // Create internal session handler
-            const session = new ThinkSession(sessionId, this._conn);
-            this._conn.sessionHandlers.set(sessionId, session);
-            // Wait for MCP tools discovery
-            await this._conn.mcpHandler.waitForToolsDiscovery(sessionId, 2000);
-            try {
-                // Start the prompt without awaiting - we need to read updates concurrently
-                const promptPromise = session.sendPrompt(prompt);
-                // Read updates, forwarding events to the stream and watching for result
-                while (!resultReceived) {
-                    const update = await session.readUpdate();
-                    if (update.type === "stop") {
-                        if (!resultReceived) {
-                            stream.rejectResult(new Error("Session ended without calling return_result"));
-                        }
-                        break;
-                    }
-                    // Forward the event to stream consumers
-                    stream.pushEvent(update);
-                }
-                // Wait for the prompt to complete (it should already be done since we got a stop)
-                await promptPromise;
-                if (resultReceived && result !== undefined) {
-                    stream.resolveResult(result);
-                }
-            }
-            finally {
-                stream.close();
-                session.close();
-                this._conn.sessionHandlers.delete(sessionId);
-            }
-        }
-        finally {
-            // Unregister MCP server(s)
-            this._conn.mcpHandler.unregister(server);
-            if (skillServer) {
-                this._conn.mcpHandler.unregister(skillServer);
+            stream.pushEvent(update);
+          }
+          await promptPromise, !resultReceived && pendingToolCalls.some((c) => c.name === "return_result") && await resultReady;
+        };
+        for (await sendTurn(prompt); !resultReceived && pendingToolCalls.length > 0; ) {
+          const calls = pendingToolCalls.splice(0), results = [];
+          for (const call of calls) {
+            if (call.name === "return_result") {
+              acceptResult(call.input);
+              break;
             }
+            const tool = this._tools.get(call.name);
+            if (tool)
+              try {
+                const output = await tool.handler(call.input), text = typeof output == "string" ? output : JSON.stringify(output);
+                results.push(`Tool "${call.name}" (id: ${call.id}) result:
+${text}`);
+              } catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                results.push(`Tool "${call.name}" (id: ${call.id}) error:
+${msg}`);
+              }
+          }
+          if (resultReceived || results.length === 0)
+            break;
+          const followUp = results.join(`
+
+`) + "\n\nWhen you have your answer, call the `return_result` MCP tool with the result.";
+          await sendTurn(followUp);
         }
+        resultError ? stream.rejectResult(resultError) : resultReceived && result !== void 0 ? stream.resolveResult(result) : resultReceived ? stream.rejectResult(new TypeError("Agent returned an undefined value")) : stream.rejectResult(new Error("Agent session ended without returning a result"));
+      } finally {
+        stream.close(), session.close(), this._conn.sessionHandlers.delete(sessionId);
+      }
+    } finally {
+      this._conn.mcpHandler.unregister(server), skillServer && this._conn.mcpHandler.unregister(skillServer);
     }
+  }
 }
-/**
- * Create a new Plan for composing a prompt with tools.
- *
- * This is the factory function for creating Plan instances. It is used
- * internally by `Agent.think()` and `Session.think()`.
- */
 export function createPlan(conn, schema, existingSessionId) {
-    return new PlanImpl({
-        conn,
-        promptParts: [],
-        tools: new Map(),
-        skills: [],
-        schemaProvider: schema,
-        cwd: undefined,
-        existingSessionId,
-    });
+  return new PlanImpl({
+    conn,
+    promptParts: [],
+    tools: /* @__PURE__ */ new Map(),
+    skills: [],
+    schemaProvider: schema,
+    cwd: void 0,
+    existingSessionId
+  });
 }
-//# sourceMappingURL=think-builder.js.map