zen-code 4.6.1 → 4.7.0

package/dist/subTasks-5KLIr9iy.mjs

@@ -1,209 +0,0 @@
-import { tool as g, HumanMessage as h, SystemMessage as p } from "langchain";
-import { Command as m, Annotation as f } from "@langchain/langgraph";
-import { z as n } from "zod";
-import { createState as b } from "@langgraph-js/pro";
-import { l as y, m as w } from "./graphBuilder-B3IJ7dB2.mjs";
-n.object({
-  task_store: n.record(n.string(), n.any()).default({})
-});
-b().build({
-  task_store: f({
-    reducer: (r, t) => ({ ...r, ...t }),
-    default: () => ({})
-  })
-});
-const k = n.object({
-  task_id: n.string().optional().describe("The task id to ask the subagent, if not provided, will use the tool call id"),
-  subagent_id: n.string().describe(
-    'REQUIRED. The specific ID of the subagent to invoke (e.g., "agents/default", "agents/manager"). Must match exactly one of the available subagents listed in the system prompt.'
-  ),
-  subagent_type: n.string().describe(
-    'REQUIRED. The type/category of subagent (e.g., "general-purpose", "statusline-setup"). Must be one of the available agent types listed in the tool description.'
-  ),
-  task_description: n.string().describe("Describe the user state and what you want the subagent to do."),
-  data_transfer: n.any().optional().describe("Data to transfer to the subagent.")
-}), _ = (r, t) => g(
-  async (e, s) => {
-    const a = s.state, o = e.task_id || s.toolCall.id;
-    let i = {
-      messages: []
-    };
-    o && a?.task_store?.[o] ? i = a?.task_store[o] : (i = JSON.parse(JSON.stringify(a)), i.messages = [], i.task_store = {});
-    const l = await r(o, e, a);
-    i.messages.push(new h({ content: e.task_description })), e.data_transfer && i.messages.push(
-      new h({
-        content: `Here is the data to help you complete the task: ${JSON.stringify(
-          e.data_transfer,
-          null,
-          2
-        )}`
-      })
-    );
-    const u = await l.invoke(i), c = u.messages.at(-1), d = {
-      task_store: {
-        ...a?.task_store || {},
-        [o]: u
-      },
-      messages: [
-        {
-          role: "tool",
-          content: `task_id: ${o}
----
-` + (c?.text || ""),
-          tool_call_id: s.toolCall.id
-        }
-      ]
-    };
-    return new m({
-      update: d
-    });
-  },
-  {
-    name: "task",
-    description: `Launch a new agent to handle complex, multi-step tasks autonomously. 
-
-Available agent types and the tools they have access to:
-- general-purpose: General-purpose agent for researching complex questions, searching for code, and executing multi-step tasks. When you are searching for a keyword or file and are not confident that you will find the right match in the first few tries use this agent to perform the search for you. (Tools: *)
-- statusline-setup: Use this agent to configure the user's Claude Code status line setting. (Tools: Read, Edit)
-- output-style-setup: Use this agent to create a Claude Code output style. (Tools: Read, Write, Edit, Glob, LS, Grep)
-
-**IMPORTANT: Both subagent_id AND subagent_type are REQUIRED parameters. You must provide BOTH.**
-
-- subagent_id: The specific ID of the subagent (e.g., "agents/default", "agents/manager")
-- subagent_type: The type category of the subagent (e.g., "general-purpose", "statusline-setup")
-
-When NOT to use the Agent tool:
-- If you want to read a specific file path, use the Read or Glob tool instead of the Agent tool, to find the match more quickly
-- If you are searching for a specific class definition like "class Foo", use the Glob tool instead, to find the match more quickly
-- If you are searching for code within a specific file or set of 2-3 files, use the Read tool instead of the Agent tool, to find the match more quickly
-- Other tasks that are not related to the agent descriptions above
-
-
-Usage notes:
-1. Launch multiple agents concurrently whenever possible, to maximize performance; to do that, use a single message with multiple tool uses
-2. When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
-3. Each agent invocation is stateless. You will not be able to send additional messages to the agent, nor will the agent be able to communicate with you outside of its final report. Therefore, your prompt should contain a highly detailed task description for the agent to perform autonomously and you should specify exactly what information the agent should return back to you in its final and only message to you.
-4. The agent's outputs should generally be trusted
-5. Clearly tell the agent whether you expect it to write code or just to do research (search, file reads, web fetches, etc.), since it is not aware of the user's intent
-6. If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.
-
-Example usage:
-
-<example_agent_descriptions>
-"code-reviewer": use this agent after you are done writing a significant piece of code
-"greeting-responder": use this agent when to respond to user greetings with a friendly joke
-</example_agent_description>
-
-<example>
-user: "Please write a function that checks if a number is prime"
-assistant: Sure let me write a function that checks if a number is prime
-assistant: First let me use the Write tool to write a function that checks if a number is prime
-assistant: I'm going to use the Write tool to write the following code:
-<code>
-function isPrime(n) {
-  if (n <= 1) return false
-  for (let i = 2; i * i <= n; i++) {
-    if (n % i === 0) return false
-  }
-  return true
-}
-</code>
-<commentary>
-Since a signficant piece of code was written and the task was completed, now use the code-reviewer agent to review the code
-</commentary>
-assistant: Now let me use the code-reviewer agent to review the code
-assistant: Uses the Task tool to launch the with the code-reviewer agent 
-</example>
-
-<example>
-user: "Hello"
-<commentary>
-Since the user is greeting, use the greeting-responder agent to respond with a friendly joke
-</commentary>
-assistant: "I'm going to use the Task tool to launch the with the greeting-responder agent"
-</example>
-`,
-    schema: k
-  }
-), v = `
-
-## SubAgents System
-
-You have access to a subagent system that can delegate specialized tasks to other agents.
-
-**Available SubAgents:**
-
-{subagents_list}
-
-**How to Use SubAgents (Progressive Disclosure):**
-
-SubAgents follow a **progressive disclosure** pattern - you know they exist (name + description above), but you only delegate tasks when needed:
-
-1. **Recognize when to delegate**: Check if the user's task matches a subagent's specialization
-2. **Use the task tool**: Call the tool with the subagent's ID and a clear task description
-3. **Provide context**: Use the \`data_transfer\` parameter to pass relevant information
-4. **Get results**: The subagent will process the task and return results
-
-**When to Use SubAgents:**
-- When the user's request requires specialized knowledge or workflows
-- When a task is complex and can be broken down into subtasks
-- When you need parallel processing or different expertise areas
-- When a subagent provides proven patterns for specific domains
-
-**SubAgent Tool Usage:**
-
-The \`task\` tool is available for delegation:
-
-- **subagent_id**: The ID of the subagent to delegate to
-- **task_description**: Clear description of what needs to be done
-- **task_id** (optional): Identifier for tracking, it will automatically be generated after you run a subagent.
-- **data_transfer** (optional): Context/data to pass to the subagent
-
-**Example Workflow:**
-
-User: "Can you have the research agent look into quantum computing developments?"
-
-1. Check available subagents above → See "research" subagent with ID
-2. Use task tool with appropriate parameters
-3. Provide clear task description and any necessary context
-4. Process the results from the subagent
-
-Remember: SubAgents are tools to distribute work and leverage specialized capabilities. When in doubt, check if a subagent exists for the task!
-`;
-class U {
-  name = "SubAgentsMiddleware";
-  stateSchema = y;
-  // contextSchema = undefined;
-  tools = [];
-  agentList = Promise.resolve("");
-  constructor(t) {
-    this.agentList = this.formatSubAgentsList(t), this.tools.push(
-      _(async (e, s, a) => await w(s.subagent_id, t, a, {}, { parent_id: e }))
-    );
-  }
-  /**
-   * Format subagents metadata for display in system prompt.
-   */
-  async formatSubAgentsList(t) {
-    const e = [];
-    for (const s of await t.listAgents())
-      e.push(`- **${s.id}**: ${s.description}`), e.push(`  → Use task with subagent_id: "${s.id}"`);
-    return e.join(`
-`);
-  }
-  async wrapModelCall(t, e) {
-    const s = await this.agentList, a = v.replace("{subagents_list}", s);
-    let o;
-    t.systemPrompt ? o = t.systemPrompt + `
-
-` + a : o = a;
-    const i = new p(o), l = {
-      ...t,
-      systemMessage: i
-    };
-    return await e(l);
-  }
-}
-export {
-  U as SubAgentsMiddleware
-};