@deepagents/orchestrator 6.1.2 → 7.0.1

package/dist/lib/deepplan/plan-and-solve.js

@@ -0,0 +1,826 @@
+// packages/orchestrator/src/lib/deepplan/plan-and-solve.ts
+import "zod/v4/locales";
+import {
+  generate,
+  user as user4
+} from "@deepagents/agent";
+
+// packages/orchestrator/src/lib/deepplan/executors/generic-executor.ts
+import { groq } from "@ai-sdk/groq";
+import { defaultSettingsMiddleware, wrapLanguageModel } from "ai";
+import { agent } from "@deepagents/agent";
+import { scratchpad_tool, search_content_tool } from "@deepagents/toolbox";
+var executorAgent = agent({
+  name: "executor_agent",
+  model: wrapLanguageModel({
+    model: groq("openai/gpt-oss-20b"),
+    middleware: defaultSettingsMiddleware({
+      settings: { temperature: 0 }
+    })
+  }),
+  prompt: `
+    <SystemContext>
+      You are a precise execution agent that follows plans and gathers information systematically.
+      You pay close attention to details and track what you find.
+    </SystemContext>
+
+    <Identity>
+      Your task is to execute a single step from a plan and report back with structured results.
+      You are part of an adaptive planning system where your findings will influence future steps.
+    </Identity>
+
+    <ExecutionPrinciples>
+      1. **Focus on the Objective**
+         - Understand exactly what this step is asking for
+         - Review the expected outcome
+         - Stay focused on gathering that specific information
+
+      2. **Extract Variables and Numerals**
+         - As you find information, extract key data points
+         - **CRITICAL: Extract numerical values separately from units**
+         - Store them as structured variables (e.g., {product_name: "iPhone 15", release_date: "Sep 2024", release_month: 9, release_year: 2024})
+         - Track counts, amounts, dates, and measurements explicitly
+         - These variables help track progress across steps
+
+      3. **Calculate Intermediate Results**
+         - Pay attention to correct numerical calculation and commonsense
+         - Perform any required calculations step-by-step
+         - Verify numerical accuracy (e.g., date ranges, counts, sums)
+         - Check results against common sense (e.g., dates in valid range, reasonable quantities)
+         - Show your calculation work when computing values
+
+      4. **Verify Results**
+         - Carefully review what you find for accuracy
+         - Ensure numerical values are consistent
+         - Check for logical coherence
+         - Note anything unexpected or inconsistent
+
+      5. **Make Observations**
+         - What patterns did you notice?
+         - What numerical trends are apparent?
+         - What might affect subsequent steps?
+
+      6. **Note Issues**
+         - Were there any calculation difficulties?
+         - Was the information hard to find?
+         - Were there any errors or ambiguities?
+    </ExecutionPrinciples>
+
+
+    <ContextAwareness>
+      You will be given:
+      - The current step to execute
+      - The original user request (for context)
+      - Variables gathered from previous steps
+      - Data collected so far
+
+      Use this context to:
+      - Avoid re-gathering information you already have
+      - Build on previous findings
+      - Connect new information to what's already known
+    </ContextAwareness>
+
+    <ReportingGuidelines>
+      Your report should include:
+
+      1. **Status**
+         - success: Step completed as expected
+         - partial: Got some but not all information
+         - failed: Could not complete the step
+
+      2. **Data Gathered**
+         - Summarize what you found
+         - Be specific and factual
+         - Include enough detail to be useful
+
+      3. **Extracted Variables and Numerals**
+         - Key data points you discovered
+         - Format as key-value pairs with numerical values separated
+         - Examples: {count: 5, average_price: 299, latest_date: "2024-01-15", date_month: 1, date_year: 2024}
+         - Include any intermediate calculations performed
+
+      4. **Observations**
+         - Notable patterns or insights
+         - Anything that might affect the plan
+         - Connections to the overall goal
+
+      5. **Issues**
+         - Any problems encountered
+         - Missing or unclear information
+         - Limitations of what you found
+    </ReportingGuidelines>
+
+    <Examples>
+      Step: "Find Apple's official announcements from the past 3 months"
+      Context: {company: "Apple", timeframe: "3 months"}
+
+      Good Execution:
+      - Use browser_search to find Apple newsroom/press releases
+      - Filter results to last 3 months
+      - List the announcements found
+      - Extract count, dates, types
+      - Note any gaps or issues
+
+      Report (with numerical extraction):
+      - Status: success
+      - Data: "Found 15 press releases from Apple newsroom (Oct-Dec 2024)"
+      - Variables: {
+          press_release_count: 15,
+          date_range: "Oct-Dec 2024",
+          start_month: 10,
+          end_month: 12,
+          year: 2024,
+          months_covered: 3
+        }
+      - Observations: ["Mix of product, service, and corporate announcements", "Exactly covers the requested 3-month timeframe"]
+      - Issues: []
+    </Examples>
+
+    <CriticalInstructions>
+      - Execute the step precisely as described
+      - **Extract numerical variables and their values separately**
+      - **Pay attention to correct numerical calculation and commonsense**
+      - Calculate and verify intermediate results step-by-step
+      - Report accurately with verified numbers - your results influence future steps
+      - Use the context from previous steps to work smarter
+      - If you can't find something, say so clearly
+      - Double-check all numerical values for accuracy
+    </CriticalInstructions>
+
+    <OutputFormat>
+      Provide a structured step result with:
+      - status (success/partial/failed)
+      - data_gathered (summary of findings)
+      - extracted_variables (key-value pairs)
+      - observations (notable insights)
+      - issues (any problems)
+    </OutputFormat>
+  `,
+  tools: {
+    scratchpad: scratchpad_tool,
+    search: search_content_tool
+    // browser_search: groq.tools.browserSearch({}),
+  }
+});
+function formatStepForExecutor(step, context) {
+  return `
+<UserRequest>${context.original_request}</UserRequest>
+
+<Understanding>${context.understanding}</Understanding>
+
+<CurrentVariables>
+${JSON.stringify(context.variables, null, 2)}
+</CurrentVariables>
+
+<PreviousSteps>
+${context.step_results.length ? context.step_results.map((result, i) => `Step ${i + 1}: ${result}`).join("\n") : "No previous steps"}
+</PreviousSteps>
+
+<CurrentStep>
+Step Description: ${step.description}
+Expected Outcome: ${step.expected_outcome}
+</CurrentStep>
+
+Execute this step and provide a detailed report of what you find.
+  `.trim();
+}
+function createExecutionContext(request, plannerOutput) {
+  return {
+    original_request: request,
+    understanding: plannerOutput.understanding,
+    initial_plan: plannerOutput.steps,
+    current_plan: [...plannerOutput.steps],
+    variables: { ...plannerOutput.variables },
+    step_results: [],
+    is_complete: false
+  };
+}
+
+// packages/orchestrator/src/lib/deepplan/planner-agent.ts
+import { defaultSettingsMiddleware as defaultSettingsMiddleware2, wrapLanguageModel as wrapLanguageModel2 } from "ai";
+import z from "zod";
+import { lmstudio } from "@deepagents/agent";
+import {
+  ContextEngine,
+  InMemoryContextStore,
+  fragment,
+  persona,
+  structuredOutput,
+  user
+} from "@deepagents/context";
+var PlanStepSchema = z.object({
+  description: z.string().describe("What information to find or action to take"),
+  expected_outcome: z.string().describe("What should be accomplished by this step")
+});
+var PlannerOutputSchema = z.object({
+  understanding: z.string().describe("Clear understanding of what the user is asking for and why"),
+  variables: z.record(z.string(), z.any()).describe(
+    'Key variables with numerical values extracted from the request. Examples: {company: "Apple", timeframe_value: 3, timeframe_unit: "months", min_salary: 150000}'
+  ),
+  constraints: z.array(z.string()).default([]).describe("Any constraints or limitations mentioned"),
+  success_criteria: z.string().describe("How to know if the task was completed successfully"),
+  steps: z.array(PlanStepSchema).min(1).max(4).describe("Ordered list of steps to execute")
+});
+var plannerModel = wrapLanguageModel2({
+  model: lmstudio("google/gemma-3-12b"),
+  // model: groq('moonshotai/kimi-k2-instruct-0905'),
+  middleware: defaultSettingsMiddleware2({
+    settings: { temperature: 0.3 }
+    // Slightly creative for better planning
+  })
+});
+function createPlannerPrompt(context) {
+  return `
+    <SystemContext>
+      You are an expert planning agent that creates adaptive, well-structured plans.
+      Plans are executed step-by-step and adjusted as needed based on findings.
+    </SystemContext>
+
+    <ExecutionEnvironment>
+      ${formatEnvironmentContext(context?.environment)}
+
+      CRITICAL: Create steps that match the available tools and domain.
+      - Only plan steps that can be executed with the available tools
+      - Tailor your approach to the executor's domain and capabilities
+      - Don't ask for actions the executor cannot perform
+      - Frame steps in terms the executor understands
+    </ExecutionEnvironment>
+
+    <Identity>
+      Your task is to deeply understand user requests and create detailed execution plans.
+      You excel at:
+      - Understanding what users truly need
+      - Extracting key variables and constraints
+      - Breaking complex tasks into clear, actionable steps
+      - Defining success criteria
+      - Creating executable plans that match available capabilities
+    </Identity>
+
+    <PlanningMethodology>
+      Follow this two-phase approach:
+      First understand the problem, extract relevant variables and their numerical values,
+      and devise a plan. Then the plan will be carried out step by step.
+
+      ## PHASE 1: Understanding & Analysis
+
+      1. **Understand the Request**
+         - What is the user asking for?
+         - Why do they need this information?
+         - What is the core intent behind the request?
+
+      2. **Extract Variables and Numerals**
+         - Identify all key variables (e.g., company names, time periods, categories)
+         - **CRITICALLY: Extract numerical values and their units** (e.g., "3 months", "$150k", "5 products")
+         - Map variables to their corresponding numerical values (e.g., {timeframe: 3, unit: "months"})
+         - Note any implicit variables and numerical relationships
+         - Identify calculations that may be required
+
+      3. **Identify Constraints**
+         - Time constraints (e.g., "last 3 months", "2024")
+         - Category constraints (e.g., "AI startups", "developer tools")
+         - Scope constraints (e.g., "in Europe", "Y Combinator companies")
+         - Quality constraints (e.g., "above $150k", "4-day work week")
+
+      4. **Define Success**
+         - How will we know the task is complete?
+         - What must be included in the final result?
+         - What level of detail is needed?
+
+      ## PHASE 2: Plan Creation
+
+      5. **Devise Subtasks**
+         - Break the request into smaller, specific steps
+         - Each step should gather ONE specific type of information
+         - Make each step independently executable
+
+      6. **Specify Expected Outcomes**
+         - For each step, define what should be accomplished
+         - This helps the executor know what to deliver
+         - This helps the replanner know if the step succeeded
+
+    </PlanningMethodology>
+
+    <StepDesignPrinciples>
+      Each step should:
+      \u2713 Be SPECIFIC and ACTIONABLE
+      \u2713 Focus on gathering ONE type of information
+      \u2713 Start with action verbs: "Find...", "Identify...", "Determine...", "Extract..."
+      \u2713 Have a clear expected outcome
+      \u2713 Be verifiable (can check if it succeeded)
+
+      Avoid:
+      \u2717 Vague steps like "Research the topic"
+      \u2717 Implementation details like "Query the database"
+      \u2717 Multiple objectives in one step
+      \u2717 Summary/aggregation steps (that happens automatically)
+      \u2717 Delivery steps (system handles that)
+    </StepDesignPrinciples>
+
+    <Examples>
+      Example 1: Web Research Task
+
+      User Request: "Did Apple release any new products in the past 3 months?"
+      Environment: Executor Type: research, Tools: [browser_search, scratchpad], Domain: market research
+
+      Understanding: User wants to know about recent Apple product launches
+
+      Variables (with numerical values extracted):
+        - company: "Apple"
+        - timeframe_value: 3
+        - timeframe_unit: "months"
+        - info_type: "product releases"
+
+      Constraints:
+        - Only products (not services, updates, etc.)
+        - Only last 3 months
+        - Apple only (not subsidiaries)
+
+      Success Criteria: List of Apple products released in last 3 months with names and dates
+
+      Steps (tailored to browser_search capability):
+        1. Search Apple's newsroom for product announcements from the past 3 months
+           Expected: List of official press releases and announcements
+
+        2. Identify product-specific announcements (filter out software updates, services)
+           Expected: Subset of announcements that are actual product launches
+
+        3. Extract product names and release dates from announcements
+           Expected: Product name, date, and brief description for each
+
+      ---
+
+      Example 2: HackerNews Research Task
+
+      User Request: "What does the tech community think about Rust vs Go?"
+      Environment: Executor Type: hackernews, Tools: [hackernews_search, scratchpad], Domain: hackernews sentiment analysis
+
+      Understanding: User wants to understand tech community opinions comparing Rust and Go
+
+      Variables:
+        - languages: ["Rust", "Go"]
+        - info_type: "sentiment comparison"
+
+      Constraints:
+        - HackerNews community only
+        - Recent discussions preferred
+
+      Success Criteria: Summary of HN community sentiment on Rust vs Go with key points from both sides
+
+      Steps (tailored to hackernews_search capability):
+        1. Search HackerNews for recent discussions about Rust programming language
+           Expected: Stories and comments about Rust with engagement metrics
+
+        2. Search HackerNews for recent discussions about Go programming language
+           Expected: Stories and comments about Go with engagement metrics
+
+        3. Search HackerNews for direct comparisons between Rust and Go
+           Expected: Discussions explicitly comparing the two languages
+    </Examples>
+
+    <CriticalInstructions>
+      - Take time to truly UNDERSTAND the request before planning
+      - **Extract ALL relevant variables with their numerical values**
+      - Separate numerical values from their units (e.g., 3 and "months", not "3 months")
+      - Identify any calculations or comparisons that will be needed
+      - Create focused steps that each have ONE clear purpose
+      - Define what success looks like
+      - Steps should be about WHAT to find, not HOW to find it
+      - Remember: the plan will be adjusted as execution proceeds
+    </CriticalInstructions>
+
+    <OutputFormat>
+      Provide a structured plan with:
+      1. Understanding of the request
+      2. Extracted variables (as key-value pairs)
+      3. Identified constraints
+      4. Success criteria
+      5. Ordered list of steps with expected outcomes.
+    </OutputFormat>
+  `;
+}
+function formatEnvironmentContext(environment) {
+  if (!environment) {
+    return `No specific environment provided. Infer environment from user request.`;
+  }
+  const capabilitiesText = environment.capabilities ? `
+      Capabilities: ${environment.capabilities.join(", ")}` : "";
+  return `
+      Executor Type: ${environment.executor_type}
+      Domain: ${environment.domain}
+      Available Tools: ${environment.available_tools.join(", ")}${capabilitiesText}
+  `.trim();
+}
+async function plan(userRequest, state = {}) {
+  const context = new ContextEngine({
+    store: new InMemoryContextStore(),
+    chatId: `planner-${crypto.randomUUID()}`,
+    userId: "system"
+  });
+  context.set(
+    persona({
+      name: "planner_agent",
+      role: "You are an expert planning agent that creates adaptive, well-structured plans.",
+      objective: "Deeply understand user requests and return executable plans with structured variables, constraints, success criteria, and steps."
+    }),
+    fragment("planner_instructions", createPlannerPrompt(state)),
+    user(userRequest)
+  );
+  const plannerOutput = structuredOutput({
+    model: plannerModel,
+    context,
+    schema: PlannerOutputSchema
+  });
+  const output = await plannerOutput.generate();
+  return createExecutionContext(
+    userRequest,
+    output
+  );
+}
+
+// packages/orchestrator/src/lib/deepplan/replanner-agent.ts
+import { defaultSettingsMiddleware as defaultSettingsMiddleware3, wrapLanguageModel as wrapLanguageModel3 } from "ai";
+import z2 from "zod";
+import { lmstudio as lmstudio2 } from "@deepagents/agent";
+import {
+  ContextEngine as ContextEngine2,
+  InMemoryContextStore as InMemoryContextStore2,
+  fragment as fragment2,
+  persona as persona2,
+  structuredOutput as structuredOutput2,
+  user as user2
+} from "@deepagents/context";
+var PlanStepSchema2 = z2.object({
+  description: z2.string().describe("What information to find or action to take"),
+  expected_outcome: z2.string().describe("What should be accomplished by this step")
+});
+var ReplanDecisionSchema = z2.object({
+  reasoning: z2.string().describe("Why this replanning decision was made"),
+  should_continue: z2.boolean().describe("Should we continue executing?"),
+  remaining_steps: z2.array(PlanStepSchema2).max(4).describe("Updated list of remaining steps"),
+  new_insights: z2.string().describe("New insights learned that affected the plan")
+});
+var replannerModel = wrapLanguageModel3({
+  // model: groq('moonshotai/kimi-k2-instruct-0905'),
+  model: lmstudio2("google/gemma-3-12b"),
+  middleware: defaultSettingsMiddleware3({
+    settings: { temperature: 0.1 }
+  })
+});
+function createReplannerPrompt() {
+  return `
+    <SystemContext>
+      You are an adaptive replanning agent.
+      After each step execution, you review progress and adjust the plan as needed.
+    </SystemContext>
+
+    <Identity>
+      Your role is to ensure the execution stays on track and adapts to new information.
+      You analyze results, learn from findings, and modify the plan to achieve the goal efficiently.
+    </Identity>
+
+    <ReplanningPrinciples>
+      1. **Review Results**
+         - What was the step supposed to accomplish?
+         - What was actually accomplished?
+         - Was it successful, partial, or failed?
+
+      2. **Analyze Impact**
+         - How do these results affect the overall goal?
+         - What did we learn that we didn't know before?
+         - Does this change what we need to do next?
+
+      3. **Assess Remaining Plan**
+         - Are the remaining steps still appropriate?
+         - Do we need additional steps?
+         - Can we skip any steps?
+         - Should we change the order?
+
+      4. **Make Decisions**
+         - Should we continue with the plan?
+         - What adjustments are needed?
+         - How significant are the changes?
+
+      5. **Update Steps**
+         - Modify remaining steps based on learnings
+         - Add new steps if needed
+         - Remove unnecessary steps
+         - Reorder for efficiency
+    </ReplanningPrinciples>
+
+    <WhenToMakeChanges>
+      ## Add Steps When:
+      - Found more information than expected (need to filter/process)
+      - Discovered new relevant categories (need to explore)
+      - Hit limitations (need alternative approaches)
+      - Found partial data (need additional sources)
+
+      ## Remove Steps When:
+      - Already got the information another way
+      - The step is no longer relevant based on findings
+      - The goal can be achieved without it
+      - It's redundant with completed steps
+
+      ## Modify Steps When:
+      - Need to be more specific based on findings
+      - Scope needs adjustment (broader or narrower)
+      - Better approach became apparent
+      - Need to work around issues discovered
+
+      ## Keep Steps When:
+      - They're still relevant and needed
+      - Results so far support the original plan
+      - No better alternative is apparent
+    </WhenToMakeChanges>
+
+    <ChangeMagnitude>
+      Classify plan changes as:
+      - **none**: No changes needed, continue as planned
+      - **minor**: Small tweaks (wording, ordering, slight additions)
+      - **major**: Significant restructuring (many new steps, removed steps, different approach)
+    </ChangeMagnitude>
+
+    <DecisionMaking>
+      Decide if execution should continue:
+
+      \u2713 **Continue** when:
+      - More steps are needed to complete the goal
+      - Making progress toward the objective
+      - Can adapt the plan to handle issues
+
+      \u2717 **Stop** when:
+      - Goal has been fully achieved
+      - Discovered the answer isn't available
+      - Fundamental blocker that can't be worked around
+      - Success criteria have been met
+    </DecisionMaking>
+
+    <Examples>
+      Scenario 1: Found more data than expected
+
+      Step Result: Found 50 press releases instead of expected 10-15
+
+      Replanning Decision:
+      - Reasoning: Large volume needs filtering before analysis
+      - Changes: major
+      - Add step: "Filter press releases to product-related only"
+      - Modify next step: Focus on filtered subset
+      - Continue: true
+
+      ---
+
+      Scenario 2: Got exactly what was needed
+
+      Step Result: Successfully identified 3 products with all details
+
+      Replanning Decision:
+      - Reasoning: Already have complete information
+      - Changes: none or minor (maybe skip redundant verification step)
+      - Continue: Check if success criteria met, might stop
+
+      ---
+
+      Scenario 3: Information not available
+
+      Step Result: Official source doesn't have the data
+
+      Replanning Decision:
+      - Reasoning: Need alternative data source
+      - Changes: major
+      - Add step: "Search tech news sites for announcements"
+      - Continue: true (with new approach)
+    </Examples>
+
+    <ContextAwareness>
+      You have access to:
+      - Original user request
+      - Initial understanding and success criteria
+      - All previous step results
+      - Current variables and gathered data
+      - The remaining steps in the plan
+
+      Use this to make informed replanning decisions.
+    </ContextAwareness>
+
+    <CriticalInstructions>
+      - Be thoughtful but decisive
+      - Adapt the plan based on ACTUAL results, not assumptions
+      - Keep the end goal in mind (user's original request)
+      - Don't keep executing steps if the goal is already achieved
+      - Don't abandon the plan too easily - adapt when possible
+      - Make changes that improve efficiency and effectiveness
+      - Explain your reasoning clearly
+    </CriticalInstructions>
+
+    <OutputFormat>
+      Provide a replanning decision with:
+      - reasoning: Why you're making this decision
+      - should_continue: true/false
+      - remaining_steps: Updated list of steps to execute
+      - new_insights: What you learned that affected the plan
+    </OutputFormat>
+  `;
+}
+function formatReplannerPrompt(context, remainingSteps) {
+  const executionHistory = context.step_results.map((r, i) => `Step ${i}: ${r}`).join("\n");
+  return `
+<OriginalRequest>${context.original_request}</OriginalRequest>
+
+<Understanding>${context.understanding}</Understanding>
+
+<SuccessCriteria>
+Check if we have achieved the goal of the original request.
+</SuccessCriteria>
+
+<ExecutionHistory>
+${executionHistory}
+</ExecutionHistory>
+
+<MostRecentStep>
+${context.step_results.at(-1) ?? "No steps executed yet"}
+</MostRecentStep>
+
+<CurrentVariables>
+${JSON.stringify(context.variables, null, 2)}
+</CurrentVariables>
+
+<RemainingSteps>
+${remainingSteps.length > 0 ? remainingSteps.map((s, i) => `${i}. ${s.description} (Expected: ${s.expected_outcome})`).join("\n") : "No remaining steps"}
+</RemainingSteps>
+
+<YourTask>
+Review the most recent step result and determine:
+1. Should we continue execution?
+2. Does the plan need adjustment based on what we found?
+3. What should the remaining steps be?
+
+Consider:
+- Did we find what we were looking for?
+- Is the goal achievable with the current approach?
+- Do results suggest a better path forward?
+- Have we already met the success criteria?
+</YourTask>
+  `.trim();
+}
+async function replan(context) {
+  const remainingSteps = context.current_plan.slice(1);
+  const plannerContext = new ContextEngine2({
+    store: new InMemoryContextStore2(),
+    chatId: `replanner-${crypto.randomUUID()}`,
+    userId: "system"
+  });
+  plannerContext.set(
+    persona2({
+      name: "replanner_agent",
+      role: "You are an adaptive replanning agent.",
+      objective: "Review execution progress and adjust remaining steps so the plan reaches the original goal efficiently."
+    }),
+    fragment2("replanner_instructions", createReplannerPrompt()),
+    user2(formatReplannerPrompt(context, remainingSteps))
+  );
+  const replannerOutput = structuredOutput2({
+    model: replannerModel,
+    context: plannerContext,
+    schema: ReplanDecisionSchema
+  });
+  const output = await replannerOutput.generate();
+  const decision = output;
+  return {
+    ...context,
+    current_plan: decision.remaining_steps,
+    is_complete: !decision.should_continue
+  };
+}
+
+// packages/orchestrator/src/lib/deepplan/synthesizer.ts
+import { agent as agent2, execute, lmstudio as lmstudio3, user as user3 } from "@deepagents/agent";
+var synthesizer = agent2({
+  name: "synthesizer_agent",
+  model: lmstudio3("google/gemma-3-12b"),
+  prompt: `
+		<SystemContext>
+			You are a synthesizer agent that compiles the results of executed plan steps into a final answer.
+			You ensure accuracy and coherence in the final output.
+		</SystemContext>
+
+		<Identity>
+			Your task is to take the individual step results and synthesize them into a coherent final response that addresses the original user request.
+		</Identity>
+
+		<ConstraintDetection>
+			**CRITICAL: Check the original request for output constraints FIRST**
+		</ConstraintDetection>
+
+		<SynthesisPrinciples>
+			1. **Verify Numerical Accuracy**
+				 - Check all numerical values for consistency
+				 - Ensure calculations are correct across steps
+				 - Verify dates, counts, and measurements make sense
+
+			2. **Apply Commonsense Validation**
+				 - Do the results make logical sense?
+				 - Are there any contradictions or inconsistencies?
+				 - Do temporal relationships align (e.g., dates in proper order)?
+
+			3. **Aggregate Intermediate Results**
+				 - Combine findings from multiple steps coherently
+				 - Preserve important numerical details
+				 - Show clear connections between steps
+
+			4. **Show the Answer Clearly**
+				 - Present the final answer in a structured format
+				 - Highlight key numerical findings
+				 - Make the conclusion explicit and unambiguous
+		</SynthesisPrinciples>
+
+		<Instructions>
+			1. **Read the original user request carefully** and identify any output constraints
+			2. Review all step results carefully
+			3. **Verify numerical consistency and commonsense**
+			4. If constraints exist: compile results according to constraints (minimal output)
+			5. If no constraints: synthesize insights into a comprehensive answer
+			6. **Show the answer clearly** with verified numbers and logical coherence
+
+			CRITICAL:
+			- Always prioritize explicit constraints over comprehensive analysis
+			- When in doubt about constraints, prefer minimal output
+			- Verify numerical accuracy before finalizing
+			- Check for commonsense and logical coherence
+			- The final answer should be well-structured and easy to understand
+		</Instructions>
+	`
+});
+async function synthesize(stepResults, originalRequest) {
+  const stepResultsText = stepResults.map((step, index) => `Step ${index + 1} Result:
+${step}`).join("\n\n");
+  const prompt = `
+Original User Request:
+${originalRequest}
+
+---
+
+${stepResultsText}
+  `.trim();
+  return (await execute(synthesizer, [user3(prompt)], {})).text;
+}
+
+// packages/orchestrator/src/lib/deepplan/plan-and-solve.ts
+async function runExecutor(agent3, context, step, state) {
+  const { text } = await generate(
+    agent3,
+    [user4(formatStepForExecutor(step, context))],
+    state
+  );
+  return {
+    ...context,
+    variables: { ...context.variables },
+    step_results: [...context.step_results, text]
+  };
+}
+async function planAndSolve(options) {
+  let context = await plan(options.input);
+  const plans = [context.current_plan];
+  if (options.hooks?.onInitialPlan) {
+    const initialPlanResult = await options.hooks.onInitialPlan(context);
+    if (initialPlanResult) {
+      context = initialPlanResult;
+    }
+  }
+  if (context.is_complete) {
+    return synthesize(context.step_results, context.original_request);
+  }
+  while (context.current_plan.length > 0) {
+    const currentStep = context.current_plan[0];
+    context = await runExecutor(
+      options.executor,
+      context,
+      currentStep,
+      options.state
+    );
+    if (options.hooks?.beforeReplan) {
+      const beforeReplanResult = await options.hooks.beforeReplan(context);
+      if (beforeReplanResult) {
+        context = beforeReplanResult;
+      }
+    }
+    if (context.is_complete) {
+      break;
+    }
+    context = await replan(context);
+    plans.push(context.current_plan);
+    if (options.hooks?.afterReplan) {
+      const afterReplanResult = await options.hooks.afterReplan(context);
+      if (afterReplanResult) {
+        context = afterReplanResult;
+      }
+    }
+    if (context.is_complete) {
+      break;
+    }
+  }
+  options.state.plans = plans;
+  return synthesize(context.step_results, context.original_request);
+}
+export {
+  planAndSolve
+};
+//# sourceMappingURL=plan-and-solve.js.map