import type { AssistantMessage, AssistantMessageEvent, ImageContent, Message, Model, SimpleStreamOptions, streamSimple, TextContent, Tool, ToolResultMessage } from "@nerf/pi-ai";
import type { Static, TSchema } from "@sinclair/typebox";
/** Stream function - can return sync or Promise for async config lookup */
export type StreamFn = (...args: Parameters<typeof streamSimple>) => ReturnType<typeof streamSimple> | Promise<ReturnType<typeof streamSimple>>;
/**
 * Configuration for how tool calls from a single assistant message are executed.
 *
 * - "sequential": each tool call is prepared, executed, and finalized before the next one starts.
 * - "parallel": tool calls are prepared sequentially, then allowed tools execute concurrently.
 *   Final tool results are still emitted in assistant source order.
 */
export type ToolExecutionMode = "sequential" | "parallel";
/** A single tool call content block emitted by an assistant message. */
export type AgentToolCall = Extract<AssistantMessage["content"][number], {
    type: "toolCall";
}>;
/**
 * Result returned from `beforeToolCall`.
 *
 * Returning `{ block: true }` prevents the tool from executing. The loop emits an error tool result instead.
 * `reason` becomes the text shown in that error result. If omitted, a default blocked message is used.
 */
export interface BeforeToolCallResult {
    block?: boolean;
    reason?: string;
}
/**
 * Partial override returned from `afterToolCall`.
 *
 * Merge semantics are field-by-field:
 * - `content`: if provided, replaces the tool result content array in full
 * - `details`: if provided, replaces the tool result details value in full
 * - `isError`: if provided, replaces the tool result error flag
 *
 * Omitted fields keep the original executed tool result values.
 */
export interface AfterToolCallResult {
    content?: (TextContent | ImageContent)[];
    details?: unknown;
    isError?: boolean;
}
/** Context passed to `beforeToolCall`. */
export interface BeforeToolCallContext {
    /** The assistant message that requested the tool call. */
    assistantMessage: AssistantMessage;
    /** The raw tool call block from `assistantMessage.content`. */
    toolCall: AgentToolCall;
    /** Validated tool arguments for the target tool schema. */
    args: unknown;
    /** Current agent context at the time the tool call is prepared. */
    context: AgentContext;
}
/** Context passed to `afterToolCall`. */
export interface AfterToolCallContext {
    /** The assistant message that requested the tool call. */
    assistantMessage: AssistantMessage;
    /** The raw tool call block from `assistantMessage.content`. */
    toolCall: AgentToolCall;
    /** Validated tool arguments for the target tool schema. */
    args: unknown;
    /** The executed tool result before any `afterToolCall` overrides are applied. */
    result: AgentToolResult<any>;
    /** Whether the executed tool result is currently treated as an error. */
    isError: boolean;
    /** Current agent context at the time the tool call is finalized. */
    context: AgentContext;
}
/**
 * Configuration for the agent loop.
 */
export interface AgentLoopConfig extends SimpleStreamOptions {
    model: Model<any>;
    /**
     * Converts AgentMessage[] to LLM-compatible Message[] before each LLM call.
     *
     * Each AgentMessage must be converted to a UserMessage, AssistantMessage, or ToolResultMessage
     * that the LLM can understand. AgentMessages that cannot be converted (e.g., UI-only notifications,
     * status messages) should be filtered out.
     *
     * @example
     * ```typescript
     * convertToLlm: (messages) => messages.flatMap(m => {
     *   if (m.role === "custom") {
     *     // Convert custom message to user message
     *     return [{ role: "user", content: m.content, timestamp: m.timestamp }];
     *   }
     *   if (m.role === "notification") {
     *     // Filter out UI-only messages
     *     return [];
     *   }
     *   // Pass through standard LLM messages
     *   return [m];
     * })
     * ```
     */
    convertToLlm: (messages: AgentMessage[]) => Message[] | Promise<Message[]>;
    /**
     * Optional transform applied to the context before `convertToLlm`.
     *
     * Use this for operations that work at the AgentMessage level:
     * - Context window management (pruning old messages)
     * - Injecting context from external sources
     *
     * @example
     * ```typescript
     * transformContext: async (messages) => {
     *   if (estimateTokens(messages) > MAX_TOKENS) {
     *     return pruneOldMessages(messages);
     *   }
     *   return messages;
     * }
     * ```
     */
    transformContext?: (messages: AgentMessage[], signal?: AbortSignal) => Promise<AgentMessage[]>;
    /**
     * Resolves an API key dynamically for each LLM call.
     *
     * Useful for short-lived OAuth tokens (e.g., GitHub Copilot) that may expire
     * during long-running tool execution phases.
     */
    getApiKey?: (provider: string) => Promise<string | undefined> | string | undefined;
    /**
     * Returns steering messages to inject into the conversation mid-run.
     *
     * Called after each tool execution to check for user interruptions.
     * If messages are returned, remaining tool calls are skipped and
     * these messages are added to the context before the next LLM call.
     *
     * Use this for "steering" the agent while it's working.
     */
    getSteeringMessages?: () => Promise<AgentMessage[]>;
    /**
     * Returns follow-up messages to process after the agent would otherwise stop.
     *
     * Called when the agent has no more tool calls and no steering messages.
     * If messages are returned, they're added to the context and the agent
     * continues with another turn.
     *
     * Use this for follow-up messages that should wait until the agent finishes.
     */
    getFollowUpMessages?: () => Promise<AgentMessage[]>;
    /**
     * Tool execution mode.
     * - "sequential": execute tool calls one by one
     * - "parallel": preflight tool calls sequentially, then execute allowed tools concurrently
     *
     * Default: "parallel"
     */
    toolExecution?: ToolExecutionMode;
    /**
     * Called before a tool is executed, after arguments have been validated.
     *
     * Return `{ block: true }` to prevent execution. The loop emits an error tool result instead.
     * The hook receives the agent abort signal and is responsible for honoring it.
     */
    beforeToolCall?: (context: BeforeToolCallContext, signal?: AbortSignal) => Promise<BeforeToolCallResult | undefined>;
    /**
     * Called after a tool finishes executing, before final tool events are emitted.
     *
     * Return an `AfterToolCallResult` to override parts of the executed tool result:
     * - `content` replaces the full content array
     * - `details` replaces the full details payload
     * - `isError` replaces the error flag
     *
     * Any omitted fields keep their original values. No deep merge is performed.
     * The hook receives the agent abort signal and is responsible for honoring it.
     */
    afterToolCall?: (context: AfterToolCallContext, signal?: AbortSignal) => Promise<AfterToolCallResult | undefined>;
    /**
     * When true, tool calls in assistant messages are rendered in the TUI
     * but NOT executed locally. Used for providers that handle tool execution
     * internally (e.g., Claude Code CLI via Agent SDK).
     *
     * The agent loop emits tool_execution_start/end events for TUI rendering
     * but skips tool.execute() and does not add tool results to context.
     */
    externalToolExecution?: boolean;
}
/**
 * Thinking/reasoning level for models that support it.
 * Note: "xhigh" is only supported by OpenAI gpt-5.1-codex-max, gpt-5.2, gpt-5.2-codex, gpt-5.3, and gpt-5.3-codex models.
 */
export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
/**
 * Extensible interface for custom app messages.
 * Apps can extend via declaration merging:
 *
 * @example
 * ```typescript
 * declare module "@mariozechner/agent" {
 *   interface CustomAgentMessages {
 *     artifact: ArtifactMessage;
 *     notification: NotificationMessage;
 *   }
 * }
 * ```
 */
export interface CustomAgentMessages {
}
/**
 * AgentMessage: Union of LLM messages + custom messages.
 * This abstraction allows apps to add custom message types while maintaining
 * type safety and compatibility with the base LLM messages.
 */
export type AgentMessage = Message | CustomAgentMessages[keyof CustomAgentMessages];
/**
 * Agent state containing all configuration and conversation data.
 */
export interface AgentState {
    systemPrompt: string;
    model: Model<any>;
    thinkingLevel: ThinkingLevel;
    tools: AgentTool<any>[];
    messages: AgentMessage[];
    isStreaming: boolean;
    streamMessage: AgentMessage | null;
    pendingToolCalls: Set<string>;
    error?: string;
    /**
     * The model currently being used for inference. Set at _runLoop() start,
     * cleared when the loop ends. When present, UI should display this instead
     * of `model` to avoid showing a stale value after a mid-turn model switch.
     */
    activeInferenceModel?: Model<any>;
}
export interface AgentToolResult<T> {
    content: (TextContent | ImageContent)[];
    details: T;
}
export type AgentToolUpdateCallback<T = any> = (partialResult: AgentToolResult<T>) => void;
export interface AgentTool<TParameters extends TSchema = TSchema, TDetails = any> extends Tool<TParameters> {
    label: string;
    execute: (toolCallId: string, params: Static<TParameters>, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<TDetails>) => Promise<AgentToolResult<TDetails>>;
    /** Normalize or migrate raw arguments before schema validation. */
    prepareArguments?: (args: Record<string, unknown>) => Record<string, unknown>;
}
export interface AgentContext {
    systemPrompt: string;
    messages: AgentMessage[];
    tools?: AgentTool<any>[];
}
/**
 * Events emitted by the Agent for UI updates.
 * These events provide fine-grained lifecycle information for messages, turns, and tool executions.
 */
export type AgentEvent = {
    type: "agent_start";
} | {
    type: "agent_end";
    messages: AgentMessage[];
} | {
    type: "turn_start";
} | {
    type: "turn_end";
    message: AgentMessage;
    toolResults: ToolResultMessage[];
} | {
    type: "message_start";
    message: AgentMessage;
} | {
    type: "message_update";
    message: AgentMessage;
    assistantMessageEvent: AssistantMessageEvent;
} | {
    type: "message_end";
    message: AgentMessage;
} | {
    type: "tool_execution_start";
    toolCallId: string;
    toolName: string;
    args: any;
} | {
    type: "tool_execution_update";
    toolCallId: string;
    toolName: string;
    args: any;
    partialResult: any;
} | {
    type: "tool_execution_end";
    toolCallId: string;
    toolName: string;
    result: any;
    isError: boolean;
};
//# sourceMappingURL=types.d.ts.map