@deepagents/orchestrator 0.1.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1 @@
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/lib/arxiv/arxiv.d.ts

@@ -0,0 +1,8 @@
+interface ArxivAgentContext {
+    pdf_url: string;
+    store_path: string;
+}
+export declare function queryArxivPaper(query: string, pdfUrl: string, storePath: string): Promise<any[]>;
+export declare const arxivAgent: import("@deepagents/agent").Agent<unknown, ArxivAgentContext>;
+export {};
+//# sourceMappingURL=arxiv.d.ts.map

package/dist/lib/arxiv/arxiv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arxiv.d.ts","sourceRoot":"","sources":["../../../src/lib/arxiv/arxiv.ts"],"names":[],"mappings":"AAyCA,UAAU,iBAAiB;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,wBAAsB,eAAe,CACnC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,kBASlB;AAuDD,eAAO,MAAM,UAAU,+DAiBrB,CAAC"}

package/dist/lib/deepplan/deepplan.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=deepplan.d.ts.map

package/dist/lib/deepplan/deepplan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepplan.d.ts","sourceRoot":"","sources":["../../../src/lib/deepplan/deepplan.ts"],"names":[],"mappings":""}

package/dist/lib/deepplan/executor-agent.d.ts

@@ -0,0 +1,53 @@
+import type { PlanStep, PlannerOutput } from './planner-agent.ts';
+/**
+ * Executor Agent
+ *
+ * Executes individual plan steps while:
+ * 1. Tracking what information is gathered
+ * 2. Extracting numerical variables from results
+ * 3. Calculating intermediate results with attention to accuracy
+ * 4. Paying attention to correct numerical calculation and commonsense
+ * 5. Making observations about findings
+ * 6. Noting any issues or unexpected results
+ */
+export declare const executorAgent: import("@deepagents/agent").Agent<unknown, import("@deepagents/agent").ContextVariables>;
+/**
+ * Format step for executor with full context
+ */
+export declare function formatStepForExecutor(step: PlanStep, context: ExecutionContext): string;
+export interface ExecutionContext {
+    original_request: string;
+    understanding: string;
+    initial_plan: PlanStep[];
+    current_plan: PlanStep[];
+    variables: Record<string, string | number | boolean>;
+    step_results: string[];
+    is_complete: boolean;
+    success_criteria_met?: boolean;
+}
+export declare function createExecutionContext(request: string, plannerOutput: PlannerOutput): ExecutionContext;
+/**
+ * Final result of the entire planning and execution process
+ */
+export interface AdaptivePlanResult {
+    original_request: string;
+    understanding: string;
+    success: boolean;
+    completion_status: 'completed' | 'partial' | 'failed';
+    final_data: Record<string, unknown>;
+    execution_history: string[];
+    execution_context: ExecutionContext;
+}
+export declare function run(step: PlanStep, context: ExecutionContext): Promise<{
+    variables: {
+        [x: string]: string | number | boolean;
+    };
+    step_results: string[];
+    original_request: string;
+    understanding: string;
+    initial_plan: PlanStep[];
+    current_plan: PlanStep[];
+    is_complete: boolean;
+    success_criteria_met?: boolean;
+}>;
+//# sourceMappingURL=executor-agent.d.ts.map

package/dist/lib/deepplan/executor-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor-agent.d.ts","sourceRoot":"","sources":["../../../src/lib/deepplan/executor-agent.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAElE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,0FAmJxB,CAAC;AAEH;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,gBAAgB,GACxB,MAAM,CAqBR;AAED,MAAM,WAAW,gBAAgB;IAE/B,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IAGtB,YAAY,EAAE,QAAQ,EAAE,CAAC;IACzB,YAAY,EAAE,QAAQ,EAAE,CAAC;IAGzB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;IAGrD,YAAY,EAAE,MAAM,EAAE,CAAC;IAGvB,WAAW,EAAE,OAAO,CAAC;IACrB,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,aAAa,GAC3B,gBAAgB,CAUlB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAEjC,gBAAgB,EAAE,MAAM,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IAGtB,OAAO,EAAE,OAAO,CAAC;IACjB,iBAAiB,EAAE,WAAW,GAAG,SAAS,GAAG,QAAQ,CAAC;IAGtD,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEpC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAG5B,iBAAiB,EAAE,gBAAgB,CAAC;CACrC;AAED,wBAAsB,GAAG,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,gBAAgB;;;;;sBAtD/C,MAAM;mBACT,MAAM;kBAGP,QAAQ,EAAE;kBACV,QAAQ,EAAE;iBASX,OAAO;2BACG,OAAO;GAkD/B"}

package/dist/lib/deepplan/jordan-research-demo.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=jordan-research-demo.d.ts.map

package/dist/lib/deepplan/jordan-research-demo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jordan-research-demo.d.ts","sourceRoot":"","sources":["../../../src/lib/deepplan/jordan-research-demo.ts"],"names":[],"mappings":""}

package/dist/lib/deepplan/plan-and-solve.d.ts

@@ -0,0 +1,131 @@
+import { type Agent, type ContextVariables } from '@deepagents/agent';
+import { type ExecutionContext } from './executor-agent.ts';
+/**
+ * Lifecycle hooks for Plan-and-Solve execution.
+ *
+ * These hooks allow you to intercept and react to key points in the execution lifecycle,
+ * enabling progress tracking, persistence, notifications, and custom logic injection.
+ *
+ * **Important:** You can manually terminate the execution loop by setting `context.is_complete = true`
+ * in either hook. This allows you to stop execution early based on custom conditions (e.g., user cancellation,
+ * resource limits, or completion detection).
+ */
+export interface PlanHooks {
+    /**
+     * Hook executed immediately after the initial plan is created.
+     *
+     * **When to use:**
+     * - Review and validate the initial plan
+     * - Persist the initial plan to storage
+     * - Log the planned steps for auditing
+     * - Modify the plan before execution starts
+     * - Display the plan to users for confirmation
+     * - Estimate total execution time or cost
+     * - **Terminate execution before it starts** by setting `context.is_complete = true`
+     *
+     * **Timing:** After the planner agent creates the initial plan, before any step execution
+     *
+     * @param context - Initial execution context with the complete plan
+     * @returns Modified context (or undefined to keep current context)
+     *
+     * @example
+     * ```typescript
+     * onInitialPlan: async (context) => {
+     *   // Log the initial plan
+     *   console.log(`Plan created with ${context.current_plan.length} steps`);
+     *
+     *   // Save for later review
+     *   await writeFile('initial_plan.json', JSON.stringify(context, null, 2));
+     *
+     *   // Validate plan isn't too complex
+     *   if (context.current_plan.length > 20) {
+     *     console.error('Plan too complex, aborting');
+     *     context.is_complete = true;
+     *   }
+     *
+     *   return context;
+     * }
+     * ```
+     */
+    onInitialPlan?: (context: ExecutionContext) => Promise<ExecutionContext | void> | ExecutionContext | void;
+    /**
+     * Hook executed before replanning occurs (after a step completes).
+     *
+     * **When to use:**
+     * - Save execution progress/checkpoints
+     * - Log intermediate results for auditing
+     * - Modify context before the replanner evaluates it
+     * - Track execution metrics
+     * - Stream progress updates to a client/UI
+     * - **Terminate execution early** by setting `context.is_complete = true`
+     *
+     * **Timing:** After a step executes, before the replanner agent runs
+     *
+     * @param context - Current execution state including completed step results
+     * @returns Modified context (or undefined to keep current context)
+     */
+    beforeReplan?: (context: ExecutionContext) => Promise<ExecutionContext | void> | ExecutionContext | void;
+    /**
+     * Hook executed after replanning occurs and the plan is updated.
+     *
+     * **When to use:**
+     * - Persist the updated plan to storage
+     * - Log plan changes and reasoning
+     * - Notify users of plan adjustments
+     * - Update progress indicators
+     * - Implement custom plan filtering/validation
+     * - Stream plan updates to a dashboard
+     * - Send alerts if major changes occur
+     * - **Terminate execution early** by setting `context.is_complete = true`
+     *
+     * **Timing:** After the replanner agent has updated the plan, before next step execution
+     *
+     * @param context - Current execution state with updated plan
+     * @returns Modified context (or undefined to keep current context)
+     */
+    afterReplan?: (context: ExecutionContext) => Promise<ExecutionContext | void> | ExecutionContext | void;
+}
+/**
+ * Executes a Plan-and-Solve Plus (PS+) workflow with adaptive replanning.
+ *
+ * This function creates a complete autonomous task execution pipeline:
+ * 1. Plans the task into specific steps
+ * 2. Executes each step sequentially
+ * 3. Replans after each execution to adapt based on results
+ * 4. Synthesizes results into a final output
+ *
+ * @param options - Configuration for the plan-and-solve execution
+ * @param options.input - The user's request or task description
+ * @param options.executor - The agent that will execute individual plan steps
+ * @param options.state - Execution context variables (e.g., repo_path, API keys)
+ * @param options.hooks - Optional lifecycle hooks for extensibility (see {@link PlanHooks})
+ *
+ * @example
+ * ```typescript
+ * const result = await planAndSolve({
+ *   input: "Find all AI startups that raised Series A",
+ *   executor: myExecutor,
+ *   state: { repo_path: process.cwd() },
+ *   hooks: {
+ *     beforeReplan: async (context) => {
+ *       // Save progress before replanning
+ *       await saveCheckpoint(context);
+ *       return context;
+ *     },
+ *     afterReplan: async (context) => {
+ *       // Log plan updates
+ *       console.log(`Updated plan: ${context.current_plan.length} steps remaining`);
+ *       return context;
+ *     }
+ *   }
+ * });
+ * ```
+ */
+export declare function planAndSolve(options: {
+    input: string;
+    executor: Agent<any, any>;
+    synthesizer?: Agent<any, any>;
+    state: ContextVariables;
+    hooks?: PlanHooks;
+}): Promise<string>;
+//# sourceMappingURL=plan-and-solve.d.ts.map

package/dist/lib/deepplan/plan-and-solve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-and-solve.d.ts","sourceRoot":"","sources":["../../../src/lib/deepplan/plan-and-solve.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,KAAK,EACV,KAAK,gBAAgB,EAGtB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,KAAK,gBAAgB,EAEtB,MAAM,qBAAqB,CAAC;AAK7B;;;;;;;;;GASG;AACH,MAAM,WAAW,SAAS;IACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,aAAa,CAAC,EAAE,CACd,OAAO,EAAE,gBAAgB,KACtB,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,GAAG,gBAAgB,GAAG,IAAI,CAAC;IAEhE;;;;;;;;;;;;;;;OAeG;IACH,YAAY,CAAC,EAAE,CACb,OAAO,EAAE,gBAAgB,KACtB,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,GAAG,gBAAgB,GAAG,IAAI,CAAC;IAEhE;;;;;;;;;;;;;;;;;OAiBG;IACH,WAAW,CAAC,EAAE,CACZ,OAAO,EAAE,gBAAgB,KACtB,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,GAAG,gBAAgB,GAAG,IAAI,CAAC;CACjE;AAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IAC1B,WAAW,CAAC,EAAE,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IAC9B,KAAK,EAAE,gBAAgB,CAAC;IACxB,KAAK,CAAC,EAAE,SAAS,CAAC;CACnB,mBAkDA"}

package/dist/lib/deepplan/plan.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=plan.d.ts.map

package/dist/lib/deepplan/plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../src/lib/deepplan/plan.ts"],"names":[],"mappings":""}

package/dist/lib/deepplan/planner-agent.d.ts

@@ -0,0 +1,39 @@
+import z from 'zod';
+declare const PlanStepSchema: z.ZodObject<{
+    description: z.ZodString;
+    expected_outcome: z.ZodString;
+}, z.core.$strip>;
+export declare const PlannerOutputSchema: z.ZodObject<{
+    understanding: z.ZodString;
+    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
+    constraints: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    success_criteria: z.ZodString;
+    steps: z.ZodArray<z.ZodObject<{
+        description: z.ZodString;
+        expected_outcome: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PlanStep = z.infer<typeof PlanStepSchema>;
+export type PlannerOutput = z.infer<typeof PlannerOutputSchema>;
+/**
+ * Planner agent that creates structured execution plans:
+ * 1. Understanding Phase: Deeply understand the user's request
+ * 2. Variable Extraction: Extract relevant variables and their corresponding numerical values
+ * 3. Plan Devising: Break down into specific, actionable steps
+ * 4. Success Criteria: Define how to know when the task is complete
+ *
+ * Enhanced with adaptive replanning for dynamic task execution.
+ */
+export declare const plannerAgent: import("@deepagents/agent").Agent<{
+    understanding: string;
+    variables: Record<string, any>;
+    constraints: string[];
+    success_criteria: string;
+    steps: {
+        description: string;
+        expected_outcome: string;
+    }[];
+}, import("@deepagents/agent").ContextVariables>;
+export declare function plan(userRequest: string): Promise<import("./executor-agent.ts").ExecutionContext>;
+export {};
+//# sourceMappingURL=planner-agent.d.ts.map

package/dist/lib/deepplan/planner-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-agent.d.ts","sourceRoot":"","sources":["../../../src/lib/deepplan/planner-agent.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAC;AAMpB,QAAA,MAAM,cAAc;;;iBAOlB,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;iBAqB9B,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY;;;;;;;;;gDAoIvB,CAAC;AAEH,wBAAsB,IAAI,CAAC,WAAW,EAAE,MAAM,2DAO7C"}

package/dist/lib/deepplan/product-manager-executor.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Product Manager Executor Agent
+ *
+ * Specialized executor that approaches tasks from a Product Management perspective.
+ * Primary responsibilities:
+ * 1. Analyzing codebases to understand features and functionality
+ * 2. Generating comprehensive user stories with acceptance criteria
+ * 3. Identifying technical dependencies and complexity
+ * 4. Prioritizing work based on business value and technical constraints
+ * 5. Creating product documentation that bridges business and technical domains
+ */
+export declare const productManagerExecutor: import("@deepagents/agent").Agent<unknown, import("@deepagents/agent").ContextVariables>;
+//# sourceMappingURL=product-manager-executor.d.ts.map

package/dist/lib/deepplan/product-manager-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"product-manager-executor.d.ts","sourceRoot":"","sources":["../../../src/lib/deepplan/product-manager-executor.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,sBAAsB,0FAoNjC,CAAC"}

package/dist/lib/deepplan/replanner-agent.d.ts

@@ -0,0 +1,47 @@
+import z from 'zod';
+import { type ExecutionContext } from './executor-agent.ts';
+import type { PlanStep } from './planner-agent.ts';
+export declare const ReplanDecisionSchema: z.ZodObject<{
+    reasoning: z.ZodString;
+    should_continue: z.ZodBoolean;
+    remaining_steps: z.ZodArray<z.ZodObject<{
+        description: z.ZodString;
+        expected_outcome: z.ZodString;
+    }, z.core.$strip>>;
+    new_insights: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type ReplanDecision = z.infer<typeof ReplanDecisionSchema>;
+/**
+ * Replanner Agent
+ *
+ * After each step execution, the replanner:
+ * 1. Reviews what was accomplished vs what was expected
+ * 2. Analyzes how this affects the remaining plan
+ * 3. Decides if the plan needs adjustment
+ * 4. Updates remaining steps based on new information
+ *
+ * This creates an adaptive planning system that learns as it executes.
+ */
+export declare const replannerAgent: import("@deepagents/agent").Agent<{
+    reasoning: string;
+    should_continue: boolean;
+    remaining_steps: {
+        description: string;
+        expected_outcome: string;
+    }[];
+    new_insights: string[];
+}, import("@deepagents/agent").ContextVariables>;
+export declare function replan(context: ExecutionContext): Promise<{
+    current_plan: {
+        description: string;
+        expected_outcome: string;
+    }[];
+    is_complete: boolean;
+    original_request: string;
+    understanding: string;
+    initial_plan: PlanStep[];
+    variables: Record<string, string | number | boolean>;
+    step_results: string[];
+    success_criteria_met?: boolean;
+}>;
+//# sourceMappingURL=replanner-agent.d.ts.map

package/dist/lib/deepplan/replanner-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replanner-agent.d.ts","sourceRoot":"","sources":["../../../src/lib/deepplan/replanner-agent.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAC;AAIpB,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAUnD,eAAO,MAAM,oBAAoB;;;;;;;;iBAW/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc;;;;;;;;gDA6JzB,CAAC;AAkDH,wBAAsB,MAAM,CAAC,OAAO,EAAE,gBAAgB;;;;;;;;;;;;GAarD"}

package/dist/lib/deepplan/research-executor.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Research Executor Agent
+ *
+ * Specialized for socioeconomic and market research tasks:
+ * - Gathering data from multiple sources
+ * - Extracting numerical data with precision
+ * - Cross-verifying information
+ * - Tracking source credibility
+ * - Identifying data gaps and contradictions
+ */
+export declare const researchExecutor: import("@deepagents/agent").Agent<unknown, import("@deepagents/agent").ContextVariables>;
+//# sourceMappingURL=research-executor.d.ts.map

package/dist/lib/deepplan/research-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"research-executor.d.ts","sourceRoot":"","sources":["../../../src/lib/deepplan/research-executor.ts"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,0FAsL3B,CAAC"}

package/dist/lib/deepplan/synthesizer.d.ts

@@ -0,0 +1,2 @@
+export declare function synthesize(stepResults: string[], originalRequest: string): Promise<string>;
+//# sourceMappingURL=synthesizer.d.ts.map

package/dist/lib/deepplan/synthesizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"synthesizer.d.ts","sourceRoot":"","sources":["../../../src/lib/deepplan/synthesizer.ts"],"names":[],"mappings":"AAgEA,wBAAgB,UAAU,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,eAAe,EAAE,MAAM,mBAexE"}

package/dist/lib/deepresearch.v0.d.ts

@@ -0,0 +1,3 @@
+export declare function getNewSearchQueries(userQuery: string, previousSearchQueries: string[], allContexts: string[], repoContext: string): Promise<string[]>;
+export declare function generateFinalReport(userQuery: string, formatting: string, allContexts: string[]): Promise<string>;
+//# sourceMappingURL=deepresearch.v0.d.ts.map

package/dist/lib/deepresearch.v0.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepresearch.v0.d.ts","sourceRoot":"","sources":["../../src/lib/deepresearch.v0.ts"],"names":[],"mappings":"AAuHA,wBAAsB,mBAAmB,CACvC,SAAS,EAAE,MAAM,EACjB,qBAAqB,EAAE,MAAM,EAAE,EAC/B,WAAW,EAAE,MAAM,EAAE,EACrB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,EAAE,CAAC,CAwCnB;AAED,wBAAsB,mBAAmB,CACvC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EAAE,GACpB,OAAO,CAAC,MAAM,CAAC,CAUjB"}

package/dist/lib/deepresearch.v1.d.ts

@@ -0,0 +1,30 @@
+export interface SearchEntry {
+    title: string;
+    url: string;
+    content: string;
+    query: string;
+}
+export interface ParagraphResearchState {
+    searchHistory: SearchEntry[];
+    latestSummary: string;
+    reflectionIteration: number;
+}
+export interface ParagraphPlan {
+    title: string;
+    content: string;
+    research: ParagraphResearchState;
+}
+export interface ResearchState {
+    reportTitle: string;
+    paragraphs: ParagraphPlan[];
+}
+export interface ResearchOptions {
+    maxReflections?: number;
+    stopOnDuplicateQuery?: boolean;
+}
+export declare function researchParagraph(userQuery: string, paragraph: ParagraphPlan, options?: ResearchOptions): Promise<void>;
+export declare function deepresearch(userQuery: string, options?: ResearchOptions): Promise<{
+    state: ResearchState;
+    markdown: string;
+}>;
+//# sourceMappingURL=deepresearch.v1.d.ts.map

package/dist/lib/deepresearch.v1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepresearch.v1.d.ts","sourceRoot":"","sources":["../../src/lib/deepresearch.v1.ts"],"names":[],"mappings":"AAiBA,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,WAAW,EAAE,CAAC;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,sBAAsB,CAAC;CAClC;AAED,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,aAAa,EAAE,CAAC;CAC7B;AAgMD,MAAM,WAAW,eAAe;IAC9B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAOD,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,aAAa,EACxB,OAAO,GAAE,eAAoB,iBA6C9B;AAED,wBAAsB,YAAY,CAChC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC;IAAE,KAAK,EAAE,aAAa,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAmBrD"}

package/dist/lib/deepwiki/complete-wiki.d.ts

@@ -0,0 +1,20 @@
+import { type Outline } from './outline-agent.ts';
+type WikiResult = {
+    files: Record<string, string>;
+    index: string;
+};
+/**
+ * Generate a complete multi-page wiki from an outline
+ *
+ * This function creates separate markdown files for each section:
+ * - Leaf sections get comprehensive content written by agents
+ * - Parent sections get TOC-style pages with introductions and links to children
+ * - All files use flat naming with full hierarchical path
+ */
+export declare function completeWiki(state: {
+    repo_path: string;
+    outline: Outline;
+    tree: string;
+}): Promise<WikiResult>;
+export {};
+//# sourceMappingURL=complete-wiki.d.ts.map

package/dist/lib/deepwiki/complete-wiki.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complete-wiki.d.ts","sourceRoot":"","sources":["../../../src/lib/deepwiki/complete-wiki.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,KAAK,OAAO,EAAY,MAAM,oBAAoB,CAAC;AA2C5D,KAAK,UAAU,GAAG;IAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAyJF;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAAC,KAAK,EAAE;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,OAAO,CAAC,UAAU,CAAC,CAoCtB"}

package/dist/lib/deepwiki/deepwiki.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=deepwiki.d.ts.map

package/dist/lib/deepwiki/deepwiki.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepwiki.d.ts","sourceRoot":"","sources":["../../../src/lib/deepwiki/deepwiki.ts"],"names":[],"mappings":""}

package/dist/lib/deepwiki/gitignore-agent.d.ts

@@ -0,0 +1,4 @@
+export declare const ignoreAgent: import("@deepagents/agent").Agent<{
+    repo_path: string;
+}, import("@deepagents/agent").ContextVariables>;
+//# sourceMappingURL=gitignore-agent.d.ts.map

package/dist/lib/deepwiki/gitignore-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gitignore-agent.d.ts","sourceRoot":"","sources":["../../../src/lib/deepwiki/gitignore-agent.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,WAAW;eAAsB,MAAM;gDAkClD,CAAC"}

package/dist/lib/deepwiki/outline-agent.d.ts

@@ -0,0 +1,22 @@
+import z from 'zod';
+declare const BaseOutlineItem: z.ZodObject<{
+    title: z.ZodString;
+}, z.core.$strip>;
+type OutlineItem = z.output<typeof BaseOutlineItem> & {
+    sections?: z.output<typeof OutlineItemSchema>[];
+};
+declare const OutlineItemSchema: z.ZodType<OutlineItem>;
+declare const OutlineSchema: z.ZodArray<z.ZodType<OutlineItem, unknown, z.core.$ZodTypeInternals<OutlineItem, unknown>>>;
+export type Outline = z.output<typeof OutlineSchema>;
+export type OutlineAgentContext = {
+    repo_path: string;
+    outline: z.output<typeof OutlineSchema>;
+    scratchpad: string;
+    tree: string;
+};
+export declare const outlineAgent: import("@deepagents/agent").Agent<unknown, OutlineAgentContext>;
+export declare const outlineCondensedAgent: import("@deepagents/agent").Agent<unknown, OutlineAgentContext>;
+export declare function generateOutline(state: OutlineAgentContext): Promise<unknown>;
+export declare function buildToc(items: OutlineItem[], baseDepth?: number, prefix?: string[]): string[];
+export {};
+//# sourceMappingURL=outline-agent.d.ts.map

package/dist/lib/deepwiki/outline-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outline-agent.d.ts","sourceRoot":"","sources":["../../../src/lib/deepwiki/outline-agent.ts"],"names":[],"mappings":"AAIA,OAAO,CAAC,MAAM,KAAK,CAAC;AAsBpB,QAAA,MAAM,eAAe;;iBAEnB,CAAC;AACH,KAAK,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,eAAe,CAAC,GAAG;IACpD,QAAQ,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,EAAE,CAAC;CACjD,CAAC;AACF,QAAA,MAAM,iBAAiB,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAI7C,CAAC;AACF,QAAA,MAAM,aAAa,6FAA6B,CAAC;AACjD,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,aAAa,CAAC,CAAC;AACrD,MAAM,MAAM,mBAAmB,GAAG;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,aAAa,CAAC,CAAC;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,eAAO,MAAM,YAAY,iEAsEvB,CAAC;AAEH,eAAO,MAAM,qBAAqB,iEA2BhC,CAAC;AAEH,wBAAsB,eAAe,CAAC,KAAK,EAAE,mBAAmB,oBAwC/D;AAWD,wBAAgB,QAAQ,CACtB,KAAK,EAAE,WAAW,EAAE,EACpB,SAAS,SAAI,EACb,MAAM,GAAE,MAAM,EAAO,YAatB"}

package/dist/lib/deepwiki/tools.d.ts

@@ -0,0 +1,62 @@
+export declare const read_file_tool: import("ai").Tool<{
+    filePath: string;
+    lineStart?: number | undefined;
+    lineEnd?: number | undefined;
+}, string>;
+export declare const read_dir_tool: import("ai").Tool<{
+    dir_path: string;
+}, string[]>;
+export declare const glob_tool: import("ai").Tool<{
+    pattern: string;
+}, string[]>;
+export declare const search_files_tool: import("ai").Tool<{
+    pattern: string;
+    max_results: number;
+    depth: number;
+}, string[]>;
+export declare const file_exists_tool: import("ai").Tool<{
+    filePath: string;
+}, boolean>;
+export declare const search_content_tool: ({
+    description?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    inputSchema: import("@ai-sdk/provider-utils").FlexibleSchema<unknown>;
+    onInputStart?: (options: import("ai").ToolCallOptions) => void | PromiseLike<void>;
+    onInputDelta?: (options: {
+        inputTextDelta: string;
+    } & import("ai").ToolCallOptions) => void | PromiseLike<void>;
+    onInputAvailable?: ((options: {
+        input: unknown;
+    } & import("ai").ToolCallOptions) => void | PromiseLike<void>) | undefined;
+} & {
+    outputSchema: import("@ai-sdk/provider-utils").FlexibleSchema<unknown>;
+    execute?: never;
+} & {
+    toModelOutput?: ((output: unknown) => import("@ai-sdk/provider").LanguageModelV2ToolResultPart["output"]) | undefined;
+} & {
+    type: "dynamic";
+} & {
+    type: "dynamic";
+}) | ({
+    description?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    inputSchema: import("@ai-sdk/provider-utils").FlexibleSchema<unknown>;
+    onInputStart?: (options: import("ai").ToolCallOptions) => void | PromiseLike<void>;
+    onInputDelta?: (options: {
+        inputTextDelta: string;
+    } & import("ai").ToolCallOptions) => void | PromiseLike<void>;
+    onInputAvailable?: ((options: {
+        input: unknown;
+    } & import("ai").ToolCallOptions) => void | PromiseLike<void>) | undefined;
+} & {
+    execute: import("ai").ToolExecuteFunction<unknown, unknown>;
+    outputSchema?: import("@ai-sdk/provider-utils").FlexibleSchema<unknown> | undefined;
+} & {
+    toModelOutput?: ((output: unknown) => import("@ai-sdk/provider").LanguageModelV2ToolResultPart["output"]) | undefined;
+} & {
+    type: "dynamic";
+} & {
+    type: "dynamic";
+});
+export declare function repoTree(dir_path: string): Promise<string>;
+//# sourceMappingURL=tools.d.ts.map

package/dist/lib/deepwiki/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/lib/deepwiki/tools.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,cAAc;;;;UAiEzB,CAAC;AAEH,eAAO,MAAM,aAAa;;YAcxB,CAAC;AAEH,eAAO,MAAM,SAAS;;YAoBpB,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;YAwB5B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;WAS3B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2C9B,CAAC;AAEH,wBAAsB,QAAQ,CAAC,QAAQ,EAAE,MAAM,mBAK9C"}

package/dist/lib/deepwiki/wiki-writer.d.ts

@@ -0,0 +1,9 @@
+type OutlineItem = {
+    title: string;
+    sections?: OutlineItem[];
+};
+export declare function generateWiki(outline: OutlineItem[], options: {
+    repo_path: string;
+}): Promise<string>;
+export {};
+//# sourceMappingURL=wiki-writer.d.ts.map

package/dist/lib/deepwiki/wiki-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wiki-writer.d.ts","sourceRoot":"","sources":["../../../src/lib/deepwiki/wiki-writer.ts"],"names":[],"mappings":"AAeA,KAAK,WAAW,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,WAAW,EAAE,CAAA;CAAE,CAAC;AAqF/D,wBAAsB,YAAY,CAChC,OAAO,EAAE,WAAW,EAAE,EACtB,OAAO,EAAE;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,mBAe/B"}

package/dist/lib/deepwiki/writer.d.ts

@@ -0,0 +1,12 @@
+import { type Outline } from './outline-agent.ts';
+export declare function generateWiki(options: {
+    repo_path: string;
+    outline: Outline;
+    tree: string;
+}): Promise<string>;
+export declare function singlePageWiki(state: {
+    repo_path: string;
+    outline: Outline;
+    tree: string;
+}): Promise<string>;
+//# sourceMappingURL=writer.d.ts.map

package/dist/lib/deepwiki/writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writer.d.ts","sourceRoot":"","sources":["../../../src/lib/deepwiki/writer.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,KAAK,OAAO,EAAY,MAAM,oBAAoB,CAAC;AAyI5D,wBAAsB,YAAY,CAAC,OAAO,EAAE;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,mBA6CA;AAqKD,wBAAsB,cAAc,CAAC,KAAK,EAAE;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,mBAiDA"}

package/dist/lib/graph.d.ts

@@ -0,0 +1,5 @@
+import type { Outline } from './deepwiki/outline-agent.ts';
+export declare function fold(item: Outline[number], parent: Outline[number], write: (section: Outline[number]) => Promise<string>, store: {
+    set: (key: string, value: string) => Promise<void>;
+}): Promise<void>;
+//# sourceMappingURL=graph.d.ts.map

package/dist/lib/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../src/lib/graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AA2B3D,wBAAsB,IAAI,CACxB,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,EACrB,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,EACvB,KAAK,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,EACpD,KAAK,EAAE;IACL,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACpD,iBAOF"}

package/dist/lib/openai-deepresearch/clarrify-agent.d.ts

@@ -0,0 +1,17 @@
+import z from 'zod';
+export declare const ClarrifyQuestion: z.ZodObject<{
+    need_clarification: z.ZodBoolean;
+    question: z.ZodString;
+    verification: z.ZodString;
+}, z.core.$strip>;
+export declare const clarrifyAgent: import("@deepagents/agent").Agent<{
+    need_clarification: boolean;
+    question: string;
+    verification: string;
+}, import("@deepagents/agent").ContextVariables>;
+export declare function clarrifyUserQuery(state: any, query: string): Promise<{
+    need_clarification: boolean;
+    question: string;
+    verification: string;
+}>;
+//# sourceMappingURL=clarrify-agent.d.ts.map

package/dist/lib/openai-deepresearch/clarrify-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clarrify-agent.d.ts","sourceRoot":"","sources":["../../../src/lib/openai-deepresearch/clarrify-agent.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAC;AA8CpB,eAAO,MAAM,gBAAgB;;;;iBAY3B,CAAC;AAEH,eAAO,MAAM,aAAa;;;;gDAMxB,CAAC;AAEH,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM;;;;GAQhE"}

package/dist/lib/openai-deepresearch/lead-research.d.ts

@@ -0,0 +1,7 @@
+export type LeadResearcherState = {
+    max_researcher_iterations: number;
+    max_concurrent_research_units: number;
+    research_iterations: number;
+};
+export declare const leadResearcherAgent: import("@deepagents/agent").Agent<unknown, LeadResearcherState>;
+//# sourceMappingURL=lead-research.d.ts.map

package/dist/lib/openai-deepresearch/lead-research.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lead-research.d.ts","sourceRoot":"","sources":["../../../src/lib/openai-deepresearch/lead-research.ts"],"names":[],"mappings":"AAwEA,MAAM,MAAM,mBAAmB,GAAG;IAChC,yBAAyB,EAAE,MAAM,CAAC;IAClC,6BAA6B,EAAE,MAAM,CAAC;IACtC,mBAAmB,EAAE,MAAM,CAAC;CAC7B,CAAC;AACF,eAAO,MAAM,mBAAmB,iEAwC9B,CAAC"}

package/dist/lib/openai-deepresearch/openai-deepresearch.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=openai-deepresearch.d.ts.map

package/dist/lib/openai-deepresearch/openai-deepresearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-deepresearch.d.ts","sourceRoot":"","sources":["../../../src/lib/openai-deepresearch/openai-deepresearch.ts"],"names":[],"mappings":""}

package/dist/lib/openai-deepresearch/reasearcher.d.ts

@@ -0,0 +1,2 @@
+export declare const researcherAgent: import("@deepagents/agent").Agent<unknown, import("@deepagents/agent").ContextVariables>;
+//# sourceMappingURL=reasearcher.d.ts.map

package/dist/lib/openai-deepresearch/reasearcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reasearcher.d.ts","sourceRoot":"","sources":["../../../src/lib/openai-deepresearch/reasearcher.ts"],"names":[],"mappings":"AAmDA,eAAO,MAAM,eAAe,0FAQ1B,CAAC"}

package/dist/lib/openai-deepresearch/research-brief.d.ts

@@ -0,0 +1,11 @@
+import z from 'zod';
+export declare const ResearchTopic: z.ZodObject<{
+    research_brief: z.ZodString;
+}, z.core.$strip>;
+export declare const researchTopicAgent: import("@deepagents/agent").Agent<{
+    research_brief: string;
+}, import("@deepagents/agent").ContextVariables>;
+export declare function transformMessagesIntoResearchTopic(userQuery: string): Promise<{
+    research_brief: string;
+}>;
+//# sourceMappingURL=research-brief.d.ts.map

package/dist/lib/openai-deepresearch/research-brief.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"research-brief.d.ts","sourceRoot":"","sources":["../../../src/lib/openai-deepresearch/research-brief.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAC;AAgCpB,eAAO,MAAM,aAAa;;iBAIxB,CAAC;AAEH,eAAO,MAAM,kBAAkB;;gDAK7B,CAAC;AAEH,wBAAsB,kCAAkC,CAAC,SAAS,EAAE,MAAM;;GAYzE"}

package/dist/lib/pipe.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pipe.d.ts.map

package/dist/lib/pipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe.d.ts","sourceRoot":"","sources":["../../src/lib/pipe.ts"],"names":[],"mappings":""}

package/dist/lib/plan-and-solve/examples.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Example problems from different reasoning categories
+ * Based on the paper's evaluation datasets
+ */
+export declare const EXAMPLE_PROBLEMS: {
+    arithmetic: {
+        simple: string;
+        complex: string;
+        multistep: string;
+    };
+    symbolic: {
+        pattern: string;
+        sequence: string;
+        logic: string;
+    };
+    commonsense: {
+        physical: string;
+        temporal: string;
+        social: string;
+    };
+};
+/**
+ * Run a single problem with PS+ (deterministic, temperature=0)
+ */
+export declare function runSinglePath(problem: string): Promise<{
+    understanding?: string | undefined;
+    plan?: (string | undefined)[] | undefined;
+    variables?: {
+        [x: string]: any;
+    } | undefined;
+    reasoning_steps?: ({
+        step_number?: number | undefined;
+        description?: string | undefined;
+        reasoning?: string | undefined;
+        result?: string | undefined;
+    } | undefined)[] | undefined;
+    final_answer?: string | number | undefined;
+    calculations?: ({
+        expression?: string | undefined;
+        result?: string | number | undefined;
+    } | undefined)[] | undefined;
+}>;
+/**
+ * Run a problem with self-consistency (multiple paths, temperature=0.7)
+ */
+export declare function runSelfConsistency(problem: string, numPaths?: number): Promise<{
+    answers: {
+        answer: string | number;
+        reasoning_path: string;
+        confidence?: number | undefined;
+    }[];
+    majority_answer: string | number;
+    confidence_score: number;
+    vote_distribution: Record<string, number>;
+}>;
+/**
+ * Compare single-path vs self-consistency for a given problem
+ */
+export declare function compareApproaches(problem: string, numPaths?: number): Promise<{
+    singlePath: {
+        understanding?: string | undefined;
+        plan?: (string | undefined)[] | undefined;
+        variables?: {
+            [x: string]: any;
+        } | undefined;
+        reasoning_steps?: ({
+            step_number?: number | undefined;
+            description?: string | undefined;
+            reasoning?: string | undefined;
+            result?: string | undefined;
+        } | undefined)[] | undefined;
+        final_answer?: string | number | undefined;
+        calculations?: ({
+            expression?: string | undefined;
+            result?: string | number | undefined;
+        } | undefined)[] | undefined;
+    };
+    selfConsistency: {
+        answers: {
+            answer: string | number;
+            reasoning_path: string;
+            confidence?: number | undefined;
+        }[];
+        majority_answer: string | number;
+        confidence_score: number;
+        vote_distribution: Record<string, number>;
+    };
+    answersMatch: boolean;
+}>;
+/**
+ * Run all example problems (useful for testing)
+ */
+export declare function runAllExamples(): Promise<void>;
+/**
+ * Demonstrate self-consistency on a challenging problem
+ */
+export declare function demonstrateSelfConsistency(): Promise<void>;
+//# sourceMappingURL=examples.d.ts.map

package/dist/lib/plan-and-solve/examples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"examples.d.ts","sourceRoot":"","sources":["../../../src/lib/plan-and-solve/examples.ts"],"names":[],"mappings":"AASA;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;CAqB5B,CAAC;AAEF;;GAEG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM;;;;;;;;;;;;;;;;;GAYlD;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,SAAK;;;;;;;;;GAoBtE;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,SAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BpE;AAED;;GAEG;AACH,wBAAsB,cAAc,kBAiBnC;AAED;;GAEG;AACH,wBAAsB,0BAA0B,kBAO/C"}

package/dist/lib/plan-and-solve/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Plan-and-Solve Plus (PS+) Implementation
+ *
+ * Implements the enhanced PS+ prompting technique from the paper:
+ * "Plan-and-Solve Prompting: Improving Zero-Shot Chain-of-Thought Reasoning by Large Language Models"
+ * (arXiv:2305.04091)
+ *
+ * @module plan-and-solve
+ */
+export { planAndSolveAgent, createPlanAndSolveAgent, } from './plan-and-solve-agent.ts';
+export { planAndSolveWithSelfConsistency, analyzeReasoningDiversity, } from './self-consistency.ts';
+export type { ReasoningStep, PlanAndSolveOutput, SelfConsistencyResult, PlanAndSolveConfig, } from './types.ts';
+export { EXAMPLE_PROBLEMS, runSinglePath, runSelfConsistency, compareApproaches, runAllExamples, demonstrateSelfConsistency, } from './examples.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/plan-and-solve/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/plan-and-solve/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EACL,iBAAiB,EACjB,uBAAuB,GACxB,MAAM,2BAA2B,CAAC;AAGnC,OAAO,EACL,+BAA+B,EAC/B,yBAAyB,GAC1B,MAAM,uBAAuB,CAAC;AAG/B,YAAY,EACV,aAAa,EACb,kBAAkB,EAClB,qBAAqB,EACrB,kBAAkB,GACnB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,gBAAgB,EAChB,aAAa,EACb,kBAAkB,EAClB,iBAAiB,EACjB,cAAc,EACd,0BAA0B,GAC3B,MAAM,eAAe,CAAC"}

package/dist/lib/plan-and-solve/plan-and-solve-agent.d.ts

@@ -0,0 +1,37 @@
+export declare const planAndSolveAgent: import("@deepagents/agent").Agent<{
+    understanding: string;
+    plan: string[];
+    variables: Record<string, any>;
+    reasoning_steps: {
+        step_number: number;
+        description: string;
+        reasoning: string;
+        result?: string | undefined;
+    }[];
+    final_answer: string | number;
+    calculations?: {
+        expression: string;
+        result: string | number;
+    }[] | undefined;
+}, import("@deepagents/agent").ContextVariables>;
+/**
+ * Creates a Plan-and-Solve Plus agent with custom temperature
+ * Useful for self-consistency where higher temperature (0.7) is needed
+ */
+export declare function createPlanAndSolveAgent(temperature?: number): import("@deepagents/agent").Agent<{
+    understanding: string;
+    plan: string[];
+    variables: Record<string, any>;
+    reasoning_steps: {
+        step_number: number;
+        description: string;
+        reasoning: string;
+        result?: string | undefined;
+    }[];
+    final_answer: string | number;
+    calculations?: {
+        expression: string;
+        result: string | number;
+    }[] | undefined;
+}, import("@deepagents/agent").ContextVariables>;
+//# sourceMappingURL=plan-and-solve-agent.d.ts.map

package/dist/lib/plan-and-solve/plan-and-solve-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-and-solve-agent.d.ts","sourceRoot":"","sources":["../../../src/lib/plan-and-solve/plan-and-solve-agent.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;gDAiG5B,CAAC;AAEH;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,SAAI;;;;;;;;;;;;;;;iDAEtD"}

package/dist/lib/plan-and-solve/run-demo.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=run-demo.d.ts.map

package/dist/lib/plan-and-solve/run-demo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-demo.d.ts","sourceRoot":"","sources":["../../../src/lib/plan-and-solve/run-demo.ts"],"names":[],"mappings":""}

package/dist/lib/plan-and-solve/self-consistency.d.ts

@@ -0,0 +1,24 @@
+import type { SelfConsistencyResult } from './types.ts';
+/**
+ * Implements self-consistency for Plan-and-Solve Plus
+ *
+ * Self-consistency improves reasoning by:
+ * 1. Generating multiple diverse reasoning paths (with temperature > 0)
+ * 2. Extracting the final answer from each path
+ * 3. Selecting the most consistent answer via majority voting
+ *
+ * Based on the paper's configuration:
+ * - Temperature: 0.7 (for diversity)
+ * - Number of paths: 10 (default, configurable)
+ */
+export declare function planAndSolveWithSelfConsistency(problem: string, numPaths?: number): Promise<SelfConsistencyResult>;
+/**
+ * Analyzes the diversity of reasoning paths
+ * Useful for understanding how different the generated paths are
+ */
+export declare function analyzeReasoningDiversity(results: SelfConsistencyResult): {
+    uniqueAnswers: number;
+    entropy: number;
+    diversityScore: number;
+};
+//# sourceMappingURL=self-consistency.d.ts.map

package/dist/lib/plan-and-solve/self-consistency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"self-consistency.d.ts","sourceRoot":"","sources":["../../../src/lib/plan-and-solve/self-consistency.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAsB,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAE5E;;;;;;;;;;;GAWG;AACH,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,MAAM,EACf,QAAQ,SAAK,GACZ,OAAO,CAAC,qBAAqB,CAAC,CAsGhC;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,qBAAqB,GAAG;IACzE,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;CACxB,CAuBA"}

package/dist/lib/plan-and-solve/types.d.ts

@@ -0,0 +1,70 @@
+import z from 'zod';
+/**
+ * Schema for a single reasoning step in the plan
+ */
+export declare const ReasoningStepSchema: z.ZodObject<{
+    step_number: z.ZodNumber;
+    description: z.ZodString;
+    reasoning: z.ZodString;
+    result: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Schema for the complete Plan-and-Solve Plus output
+ */
+export declare const PlanAndSolveOutputSchema: z.ZodObject<{
+    understanding: z.ZodString;
+    plan: z.ZodArray<z.ZodString>;
+    variables: z.ZodRecord<z.ZodString, z.ZodAny>;
+    reasoning_steps: z.ZodArray<z.ZodObject<{
+        step_number: z.ZodNumber;
+        description: z.ZodString;
+        reasoning: z.ZodString;
+        result: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    calculations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        expression: z.ZodString;
+        result: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    }, z.core.$strip>>>;
+    final_answer: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+}, z.core.$strip>;
+/**
+ * Schema for self-consistency result
+ */
+export declare const SelfConsistencyResultSchema: z.ZodObject<{
+    answers: z.ZodArray<z.ZodObject<{
+        answer: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+        reasoning_path: z.ZodString;
+        confidence: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    majority_answer: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    confidence_score: z.ZodNumber;
+    vote_distribution: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>;
+export type ReasoningStep = z.infer<typeof ReasoningStepSchema>;
+export type PlanAndSolveOutput = z.infer<typeof PlanAndSolveOutputSchema>;
+export type SelfConsistencyResult = z.infer<typeof SelfConsistencyResultSchema>;
+/**
+ * Input configuration for Plan-and-Solve Plus
+ */
+export interface PlanAndSolveConfig {
+    /**
+     * The problem/question to solve
+     */
+    problem: string;
+    /**
+     * Temperature for generation (0 for deterministic, 0.7 for self-consistency)
+     * @default 0
+     */
+    temperature?: number;
+    /**
+     * Whether to use self-consistency (multiple reasoning paths)
+     * @default false
+     */
+    useSelfConsistency?: boolean;
+    /**
+     * Number of reasoning paths to generate for self-consistency
+     * @default 10
+     */
+    numPaths?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/plan-and-solve/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lib/plan-and-solve/types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;iBAU9B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;iBA6BnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;iBAqBtC,CAAC;AAGH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEhF;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB"}

package/dist/pro-mode.d.ts

@@ -0,0 +1,6 @@
+export interface ProModeResult {
+    final: string;
+    candidates: string[];
+}
+export declare function proMode(prompt: string, runs: number): Promise<ProModeResult>;
+//# sourceMappingURL=pro-mode.d.ts.map

package/dist/pro-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pro-mode.d.ts","sourceRoot":"","sources":["../src/pro-mode.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAkFD,wBAAsB,OAAO,CAC3B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,aAAa,CAAC,CAgBxB"}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@deepagents/orchestrator",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./dist/lib/*",
+      "import": "./dist/lib/*",
+      "default": "./dist/lib/*"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo",
+    "!**/*.test.*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@deepagents/agent": "0.1.0",
+    "@ai-sdk/groq": "2.0.24",
+    "zod": "^3.25.76 || ^4.0.0",
+    "ai": "^5.0.65",
+    "lodash-es": "^4.17.21",
+    "@deepagents/retrieval": "0.1.0",
+    "@deepagents/toolbox": "0.1.0",
+    "p-limit": "^6.1.0"
+  },
+  "peerDependencies": {},
+  "devDependencies": {
+    "@types/debug": "^4.1.12"
+  }
+}