import * as ajv from 'ajv';
import { z } from 'zod';
import { PromptTemplate } from '../../../template.js';
import { AnyTool } from '../../../tools/base.js';
import '../../../errors.js';
import '../../../internals/types.js';
import '../../../internals/helpers/guards.js';
import '../../../internals/serializable.js';
import '../../../context.js';
import '../../../emitter-l0W9gC1A.js';
import '../../../internals/helpers/promise.js';
import 'promise-based-task';
import '../../../cache/base.js';
import '../../../internals/helpers/schema.js';
import 'zod-to-json-schema';

declare function createRePlanOutputSchema<T extends AnyTool>(tools: T[]): Promise<{
    definition: z.ZodObject<{
        information: z.ZodRecord<z.ZodString, z.ZodString>;
        lookback: z.ZodString;
        plan: z.ZodArray<z.ZodObject<{
            title: z.ZodString;
            decision: z.ZodString;
            research: z.ZodBoolean;
            computation: z.ZodBoolean;
        }, "strip", z.ZodTypeAny, {
            title: string;
            decision: string;
            research: boolean;
            computation: boolean;
        }, {
            title: string;
            decision: string;
            research: boolean;
            computation: boolean;
        }>, "many">;
        nextStep: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
            type: z.ZodLiteral<"message">;
            message: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            message: string;
            type: "message";
        }, {
            message: string;
            type: "message";
        }>, ...z.ZodObject<{
            type: z.ZodLiteral<"tool">;
            calls: z.ZodArray<z.ZodDiscriminatedUnion<"name", [z.ZodObject<{
                name: z.ZodLiteral<string>;
                input: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
            }, "strip", z.ZodTypeAny, {
                name: string;
                input: {} & {
                    [k: string]: unknown;
                };
            }, {
                name: string;
                input: {} & {
                    [k: string]: unknown;
                };
            }>, ...z.ZodObject<{
                name: z.ZodLiteral<string>;
                input: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
            }, "strip", z.ZodTypeAny, {
                name: string;
                input: {} & {
                    [k: string]: unknown;
                };
            }, {
                name: string;
                input: {} & {
                    [k: string]: unknown;
                };
            }>[]]>, "many">;
        }, "strip", z.ZodTypeAny, {
            type: "tool";
            calls: {
                name: string;
                input: {} & {
                    [k: string]: unknown;
                };
            }[];
        }, {
            type: "tool";
            calls: {
                name: string;
                input: {} & {
                    [k: string]: unknown;
                };
            }[];
        }>[]]>;
    }, "strip", z.ZodTypeAny, {
        information: Record<string, string>;
        lookback: string;
        plan: {
            title: string;
            decision: string;
            research: boolean;
            computation: boolean;
        }[];
        nextStep: {
            message: string;
            type: "message";
        } | {
            type: "tool";
            calls: {
                name: string;
                input: {} & {
                    [k: string]: unknown;
                };
            }[];
        };
    }, {
        information: Record<string, string>;
        lookback: string;
        plan: {
            title: string;
            decision: string;
            research: boolean;
            computation: boolean;
        }[];
        nextStep: {
            message: string;
            type: "message";
        } | {
            type: "tool";
            calls: {
                name: string;
                input: {} & {
                    [k: string]: unknown;
                };
            }[];
        };
    }>;
    json: ajv.SchemaObject;
}>;
type RePlanState = z.output<Awaited<ReturnType<typeof createRePlanOutputSchema>>["definition"]>;
declare const RePlanSystemPrompt: PromptTemplate<z.ZodObject<{
    schema: z.ZodString;
}, "strip", z.ZodTypeAny, {
    schema: string;
}, {
    schema: string;
}>>;
declare const RePlanAssistantPrompt: PromptTemplate<z.ZodObject<{
    results: z.ZodString;
}, "strip", z.ZodTypeAny, {
    results: string;
}, {
    results: string;
}>>;

export { RePlanAssistantPrompt, type RePlanState, RePlanSystemPrompt, createRePlanOutputSchema };