import type { AgentInit, FabricContext, JsonObject, PromptOptions, SessionOptions, ShellOptions, ShellResult, Skill, SkillOptions, TaskOptions } from "./types.js";
import type { FabricSession } from "./session.js";
import type { Schema } from "./schema.js";
import type { WebhookSubscriptionDefinition } from "./webhook-subscription.js";
import type { ToolDef } from "./tools.js";
import type { CapabilityPolicy } from "./policy.js";
import { invoke as invokeJob, type JobInvocationContext } from "./job-invoke.js";
export interface AgentTriggers {
    webhook?: boolean;
    schedule?: string | string[];
    manual?: boolean;
    [key: string]: string | string[] | boolean | undefined;
}
export interface AgentDefinition<TInput = JsonObject, TOutput = unknown> {
    name?: string;
    description?: string;
    instructions?: string;
    input?: Schema<TInput>;
    output?: Schema<TOutput>;
    model?: string;
    target?: "node" | "temporal-worker";
    skills?: Skill[];
    tools?: ToolDef[];
    triggers?: AgentTriggers;
    policy?: import("./policy.js").CapabilityPolicy;
    costBudget?: import("./cost-budget.js").CostLimit;
    approvals?: import("./types.js").ApprovalOptions;
    /** Options applied when the agent lazily initializes its runtime. */
    init?: AgentInit;
    /** Ordered wrappers for logging, tracing, authorization, and shared concerns. */
    middleware?: readonly AgentMiddleware<TInput, TOutput>[];
    /**
     * Webhook subscription definitions. Each subscription gets its own HTTP
     * route (`/agents/<name>/subscriptions/<id>`) on the Node server and wakes the
     * agent on inbound events. The host event system decides what payloads
     * land here — fabric-harness has no opinion on the upstream taxonomy.
     */
    subscriptions?: WebhookSubscriptionDefinition<unknown>[];
    run: (context: AgentRunContext<TInput>) => Promise<TOutput> | TOutput;
}
/** Runtime-ready context for finite agents. The default session is initialized lazily. */
export interface AgentRunContext<TInput = JsonObject> extends FabricContext<TInput> {
    input: TInput;
    /** Stable server-side run identity, available when admitted through a job runtime. */
    run?: JobInvocationContext;
    session(id?: string, options?: SessionOptions): Promise<FabricSession>;
    prompt<TResult = string>(text: string, options?: PromptOptions<TResult>): Promise<TResult>;
    skill<TResult = string>(name: string, options?: SkillOptions<TResult>): Promise<TResult>;
    task<TResult = string>(text: string, options?: TaskOptions<TResult>): Promise<TResult>;
    shell(command: string, options?: ShellOptions): Promise<ShellResult>;
    /** Admit a child finite job without an HTTP round trip. */
    invoke: typeof invokeJob;
}
export type AgentMiddleware<TInput = JsonObject, TOutput = unknown> = {
    bivarianceHack(context: AgentRunContext<TInput>, next: () => Promise<TOutput>): Promise<TOutput> | TOutput;
}["bivarianceHack"];
declare const definitionSymbol: unique symbol;
type AgentDefinitionMetadata<TInput> = Omit<AgentDefinition<TInput, unknown>, "middleware" | "run"> & {
    middleware?: readonly AgentMiddleware<TInput, unknown>[];
    run: (context: AgentRunContext<TInput>) => unknown;
};
export type DefinedAgent<TInput = JsonObject, TOutput = unknown> = ((context: FabricContext<TInput>) => Promise<TOutput> | TOutput) & {
    readonly [definitionSymbol]: AgentDefinitionMetadata<TInput>;
    readonly __fabricAgent?: AgentDefinitionMetadata<TInput>;
};
/**
 * No-defaults finite-agent builder with lazy default-session helpers.
 *
 * The runtime admits these finite definitions through its job/run protocol,
 * but authors define an agent. Use {@link createAgent} for a persistent,
 * URL-addressable agent whose sessions span multiple submissions.
 */
export declare function defineAgent<TInput = JsonObject, TOutput = unknown>(definition: AgentDefinition<TInput, TOutput>): DefinedAgent<TInput, TOutput>;
/** Defaults-injecting finite-agent builder exported from the bare SDK entry point. */
export declare function defineAgentWithDefaults<TInput = JsonObject, TOutput = unknown>(definition: AgentDefinition<TInput, TOutput>): DefinedAgent<TInput, TOutput>;
/**
 * Treat a definition policy as a security floor. Invocation policy can add
 * denials and approval requirements, but cannot replace definition allowlists.
 */
export declare function mergeCapabilityPolicies(definition: CapabilityPolicy | undefined, invocation: CapabilityPolicy | undefined): CapabilityPolicy | undefined;
export declare function getAgentDefinition(value: unknown): AgentDefinition<unknown, unknown> | undefined;
export {};
//# sourceMappingURL=agent-definition.d.ts.map