import { I as InspectRunOptions, S as StepOptions, O as ObserveOptions } from './types-bwL8cBv5.cjs';
export { E as ErrorInfo, R as RedactionProfile, a as Run, b as RunStatus, c as Step, d as StepMetadata, e as StepStatus, f as StepType, T as TokenMetadata, g as TraceCorrelationMetadata } from './types-bwL8cBv5.cjs';
export { C as CreateInspectorOptions, I as Inspector, a as InspectorCaptureOptions, b as InspectorObserveOptions, c as InspectorRunOptions, d as InspectorStepOptions, e as createInspector, g as getCurrentCorrelationMetadata, m as maybeInspectRun } from './context-rR_jW9TH.cjs';
import { O as ObserveOutcomeOptions } from './types-BA_IOdg4.cjs';
import './log-config-CyRGaaWd.cjs';
import './inspect-event-ClM5Z8om.cjs';
import './persisted-inspect-event-q2ViiBW6.cjs';
import './writers.cjs';

/**
 * Stable v1.0 API for local manual run tracing.
 *
 * Runs `fn` inside an AgentInspect trace: JSONL `run_started` / `run_completed`, optional terminal output,
 * and {@link ExecutionContext} for nested APIs. Instrumentation failures are swallowed; user errors are re-thrown.
 */
declare function inspectRun<T>(name: string, fn: () => Promise<T> | T, options?: InspectRunOptions): Promise<T>;

/**
 * Stable v1.0 API for instrumenting a named step inside an AgentInspect run.
 *
 * Callable step tracer plus {@link step.llm} and {@link step.tool} shortcuts.
 */
type StepFunction = {
    <T>(name: string, fn: () => Promise<T> | T, options?: StepOptions): Promise<T>;
    llm: <T>(model: string, fn: () => Promise<T> | T) => Promise<T>;
    tool: <T>(toolName: string, fn: () => Promise<T> | T) => Promise<T>;
};
/**
 * Traces a named unit of work inside `inspectRun` (`step_started` / `step_completed`, optional terminal).
 * Outside a run, executes `fn` with a warn only. Preserves return values and rethrows user errors unchanged.
 *
 * - `step.llm(model, fn)` — `type: "llm"`, `metadata.model` (no SDK calls or token counting).
 * - `step.tool(toolName, fn)` — `type: "tool"`, `metadata.toolName` (no framework interception).
 */
declare const step: StepFunction;

/**
 * Stable v1.0 API for observing agent-like objects locally.
 *
 * Returns a Proxy that traces top-level `run`, `execute`, and `invoke` via {@link inspectRun}.
 * Other properties pass through; function members are bound to the real target so class private fields work.
 * Invalid agents are returned unchanged (with a warn); this function never throws.
 */
declare function observe<T>(agent: T, options?: ObserveOptions): T;

/**
 * Records an observed real-world outcome inside an active `inspectRun` context.
 * Outside a run, logs a warning and returns without throwing.
 */
declare function observeOutcome(name: string, options: ObserveOutcomeOptions): Promise<void>;

export { InspectRunOptions, ObserveOptions, ObserveOutcomeOptions, StepOptions, inspectRun, observe, observeOutcome, step };