A2A clients

export interface A2AAgentCard {
    name: string;
    description?: string;
    url: string;
    version?: string;
    provider?: {
        organization: string;
        url?: string;
    };
    capabilities?: {
        streaming?: boolean;
        pushNotifications?: boolean;
        stateTransitionHistory?: boolean;
    };
    authentication?: {
        schemes?: string[];
        credentials?: string;
    };
    skills?: A2ASkill[];
    defaultInputModes?: string[];
    defaultOutputModes?: string[];
    supportedInputModes?: string[];
    supportedOutputModes?: string[];
}

export interface A2AArtifact {
    artifactId: string;
    name?: string;
    description?: string;
    parts: A2APart[];
    metadata?: Record<string, unknown>;
}

export interface A2ADataPart {
    kind: "data";
    data: Record<string, unknown>;
}

export interface A2AFilePart {
    kind: "file";
    file: {
        name?: string;
        mimeType?: string;
        bytes?: string;
        uri?: string;
    };
}

export interface A2AJsonRpcRequest {
    jsonrpc: "2.0";
    id: string | number;
    method: string;
    params?: Record<string, unknown>;
}

export interface A2AJsonRpcResponse {
    jsonrpc: "2.0";
    id: string | number;
    result?: unknown;
    error?: {
        code: number;
        message: string;
        data?: unknown;
    };
}

export interface A2AMessage {
    role: "user" | "agent";
    parts: A2APart[];
    messageId?: string;
    taskId?: string;
    referenceTaskIds?: string[];
    metadata?: Record<string, unknown>;
}

export type A2APart = A2ATextPart | A2AFilePart | A2ADataPart;

/**
 * A2ARemoteAgent wraps a remote A2A-compliant agent.
 * It can be used as a tool, a Team member, or called directly.
 */
export declare class A2ARemoteAgent {
    readonly url: string;
    name: string;
    instructions: string;
    skills: Array<{
        id: string;
        name: string;
        description?: string;
    }>;
    get tools(): ToolDef[];
    get modelId(): string;
    get providerId(): string;
    get hasStructuredOutput(): boolean;
    constructor(config: A2ARemoteAgentConfig);
    /**
     * Fetch the Agent Card from /.well-known/agent.json and populate metadata.
     */
    discover(opts?: {
        signal?: AbortSignal;
    }): Promise<A2AAgentCard>;
    /**
     * Synchronous run: sends message/send and returns RunOutput.
     */
    run(input: string, opts?: RunOpts): Promise<RunOutput>;
    /**
     * Streaming run: sends message/stream and yields StreamChunks from SSE.
     */
    stream(input: string, opts?: RunOpts): AsyncGenerator<StreamChunk>;
    /**
     * Wrap this remote agent as a ToolDef so it can be used by an orchestrator agent.
     */
    asTool(): ToolDef;
    getAgentCard(): A2AAgentCard | null;
}

export interface A2ARemoteAgentConfig {
    url: string;
    /** Custom headers for every request (e.g. auth tokens). */
    headers?: Record<string, string>;
    /** Override the discovered name. */
    name?: string;
    /** Request timeout in ms (default 60000). */
    timeoutMs?: number;
}

/**
 * A2ARemoteTeam wraps a remote team endpoint.
 * Duck-types the Team interface so it can be used interchangeably.
 */
export declare class A2ARemoteTeam {
    readonly kind: "team";
    readonly name: string;
    constructor(config: A2ARemoteTeamConfig);
    run(input: string, opts?: RunOpts): Promise<RunOutput>;
    stream(input: string, opts?: RunOpts): AsyncGenerator<StreamChunk>;
}

export interface A2ARemoteTeamConfig {
    url: string;
    name?: string;
    headers?: Record<string, string>;
    timeoutMs?: number;
}

/**
 * A2ARemoteWorkflow wraps a remote workflow endpoint.
 */
export declare class A2ARemoteWorkflow {
    readonly kind: "workflow";
    readonly name: string;
    constructor(config: A2ARemoteWorkflowConfig);
    run(initialState?: Record<string, unknown>, opts?: {
        signal?: AbortSignal;
    }): Promise<WorkflowResult<Record<string, unknown>>>;
}

export interface A2ARemoteWorkflowConfig {
    url: string;
    name?: string;
    headers?: Record<string, string>;
    timeoutMs?: number;
}

export interface A2ASendParams {
    message: A2AMessage;
    configuration?: {
        acceptedOutputModes?: string[];
        blocking?: boolean;
    };
    metadata?: Record<string, unknown>;
}

export interface A2ASkill {
    id: string;
    name: string;
    description?: string;
    tags?: string[];
    examples?: string[];
}

export interface A2ATask {
    id: string;
    sessionId?: string;
    status: {
        state: A2ATaskState;
        message?: A2AMessage;
        timestamp?: string;
    };
    artifacts?: A2AArtifact[];
    history?: A2AMessage[];
    metadata?: Record<string, unknown>;
}

export interface A2ATaskQueryParams {
    id: string;
    historyLength?: number;
}

export type A2ATaskState = "submitted" | "working" | "input-required" | "completed" | "failed" | "canceled";

/**
 * A2A (Agent-to-Agent) Protocol types.
 * Based on the A2A specification v0.2.
 * https://google.github.io/A2A/specification/
 */
export interface A2ATextPart {
    kind: "text";
    text: string;
}

export interface A2AV1CallOptions {
    signal?: AbortSignal;
    tenant?: string;
}

export interface A2AV1Card {
    name: string;
    description: string;
    version: string;
    supportedInterfaces: Array<{
        url: string;
        protocolBinding: string;
        protocolVersion: string;
        tenant?: string;
    }>;
    capabilities?: {
        streaming?: boolean;
        pushNotifications?: boolean;
    };
    [key: string]: unknown;
}

/** Optional official-SDK adapter; importing core never loads the A2A SDK.
 * Credentials are restricted to the configured origin, including discovery. */
export declare class A2AV1Client {
    constructor(config: A2AV1ClientConfig);
    discover(options?: Pick<A2AV1CallOptions, "signal">): Promise<A2AV1Card>;
    send(message: A2AV1Message | string, options?: A2AV1CallOptions): Promise<A2AV1Task | A2AV1Message>;
    stream(message: A2AV1Message | string, options?: A2AV1CallOptions): AsyncGenerator<A2AV1StreamEvent>;
    getTask(id: string, options?: A2AV1CallOptions): Promise<A2AV1Task>;
    cancelTask(id: string, options?: A2AV1CallOptions): Promise<A2AV1Task>;
}

export interface A2AV1ClientConfig {
    url: string;
    headers?: Record<string, string>;
    fetch?: typeof fetch;
    timeoutMs?: number;
}

export interface A2AV1Message {
    messageId: string;
    role: "ROLE_USER" | "ROLE_AGENT";
    parts: A2AV1Part[];
    contextId?: string;
    taskId?: string;
    metadata?: Record<string, unknown>;
}

/** A2A 1.0 JSON parts. Wire parts stay intact, including data and media. */
export type A2AV1Part = ({
    text: string;
} | {
    data: unknown;
} | {
    raw: string;
} | {
    url: string;
}) & {
    mediaType?: string;
    filename?: string;
    metadata?: Record<string, unknown>;
};

export type A2AV1State = "TASK_STATE_SUBMITTED" | "TASK_STATE_WORKING" | "TASK_STATE_COMPLETED" | "TASK_STATE_FAILED" | "TASK_STATE_CANCELED" | "TASK_STATE_INPUT_REQUIRED" | "TASK_STATE_REJECTED" | "TASK_STATE_AUTH_REQUIRED";

export type A2AV1StreamEvent = {
    task: A2AV1Task;
} | {
    message: A2AV1Message;
} | {
    statusUpdate: {
        taskId: string;
        contextId: string;
        status: A2AV1Task["status"];
    };
} | {
    artifactUpdate: {
        taskId: string;
        contextId: string;
        artifact: NonNullable<A2AV1Task["artifacts"]>[number];
        append?: boolean;
        lastChunk?: boolean;
    };
};

export interface A2AV1Task {
    id: string;
    contextId: string;
    status: {
        state: A2AV1State;
        message?: A2AV1Message;
        timestamp?: string;
    };
    history?: A2AV1Message[];
    artifacts?: Array<{
        artifactId: string;
        parts: A2AV1Part[];
        name?: string;
        metadata?: Record<string, unknown>;
    }>;
    metadata?: Record<string, unknown>;
}