export type ToolSourceProfile = "opencode-chat-completions" | "openai-responses" | "anthropic" | "droid";
export interface ToolTransformationDiagnostic {
    code: string;
    message: string;
}
export interface ToolDefinitionIR {
    sourceProfile: ToolSourceProfile;
    sourceClient: string;
    sourceProtocol: string;
    namespace?: string;
    originalName: string;
    originalDescription: string;
    originalSchema: Record<string, unknown>;
    contract: ToolContract;
    semanticRole?: string;
    semanticRoleAuthority?: "profile_schema";
    permissionOwner: "client" | "interaction";
    nativeEligible: boolean;
    diagnostics: ToolTransformationDiagnostic[];
}
export interface ToolCallIR {
    sourceProfile: ToolSourceProfile;
    canonicalCallId: string;
    clientCallId?: string;
    cursorCallId?: string;
    execMessageId?: number;
    execId?: string;
    mcpToolCallId?: string;
    modelCallId?: string;
    wave?: number;
    parallelGroup?: string;
    index?: number;
    dependencies?: string[];
    toolName: string;
    rawArguments: unknown;
    parsedArguments?: Record<string, unknown>;
    normalizedArguments?: Record<string, unknown>;
    finalitySource: "source_final" | "exec_args" | "interaction_completed" | "partial";
    diagnostics: ToolTransformationDiagnostic[];
}
export interface ToolResultContentBlock {
    type: string;
    text?: string;
    data?: unknown;
    mediaType?: string;
}
export interface ToolResultArtifact {
    name?: string;
    uri?: string;
    mediaType?: string;
    size?: number;
    sha256?: string;
    truncated?: boolean;
    provenance?: string;
}
export interface ToolResultIR {
    sourceProfile: ToolSourceProfile;
    canonicalCallId: string;
    clientCallId?: string;
    toolCallId: string;
    content: string;
    contentBlocks: ToolResultContentBlock[];
    rawEnvelope: unknown;
    explicitError?: boolean;
    inferredError: boolean;
    isError: boolean;
    stdout?: string;
    stderr?: string;
    exitCode?: number;
    signal?: string;
    durationMs?: number;
    artifacts: ToolResultArtifact[];
    streamState: "live" | "final" | "synthetic";
    sequence?: number;
    cancelled: boolean;
    retryable?: boolean;
    diagnostics: ToolTransformationDiagnostic[];
}
export interface ToolCorrelationError {
    code: "duplicate_call_id" | "duplicate_result_id" | "missing_result" | "unknown_result_id" | "ambiguous_positional";
    id?: string;
    message: string;
}
export interface ToolCorrelationResult {
    pairs: Array<{
        call: ToolCallIR;
        result: ToolResultIR;
    }>;
    errors: ToolCorrelationError[];
}
export interface ToolContract {
    name: string;
    /** Model-facing role aliases that resolve to this tool (e.g. StrReplace). */
    aliases: readonly string[];
    /** Declared top-level property names. */
    properties: Set<string>;
    /** Declared required top-level keys (may be empty). */
    required: string[];
    /** Full parameters JSON schema when available. */
    schema?: Record<string, unknown>;
}
/** Resolve bounded local JSON pointers and expose effective composed shape. */
export declare function resolveToolSchema(schema: unknown): Record<string, unknown> | undefined;
/** Extract a ToolContract from an OpenAI/JSON-schema parameters object. */
export declare function toolContractFromSchema(name: string, schema: unknown): ToolContract;
export declare function isSchemaCompatibleWithTrustedOpenCodeRole(role: string, contract: ToolContract): boolean;
export declare function toolDefinitionIRFromOpenAI(definition: {
    type?: string;
    function?: {
        name?: string;
        description?: string;
        parameters?: Record<string, unknown>;
    };
}, sourceProfile?: ToolSourceProfile): ToolDefinitionIR;
export declare function projectToolDefinitionIRToOpenAI(definition: ToolDefinitionIR): {
    type: "function";
    function: {
        name: string;
        description: string;
        parameters: Record<string, unknown>;
    };
};
export declare function toolCallIRFromSource(sourceProfile: ToolSourceProfile, envelope: Record<string, unknown>): ToolCallIR;
export declare function inferToolResultError(content: string): boolean;
export declare function toolResultIRFromSource(sourceProfile: ToolSourceProfile, envelope: Record<string, unknown>): ToolResultIR;
export declare function correlateToolResults(calls: ToolCallIR[], results: ToolResultIR[], options?: {
    allowPositional?: boolean;
}): ToolCorrelationResult;
/** Validate already-normalized arguments against the effective tool schema. */
export declare function validateToolArguments(contract: ToolContract, args: Record<string, unknown>): string[];
export declare function formatSchemaValidationError(toolName: string, issues: readonly string[], received: readonly string[]): string;
/** Required keys present in the schema but absent from args (undefined counts as missing). */
export declare function missingRequiredKeys(args: Record<string, unknown> | null | undefined, required: readonly string[]): string[];
/** Actionable SchemaError text: missing / expected / received + no-identical-retry. */
export declare function formatMissingRequiredError(toolName: string, missing: readonly string[], expected: readonly string[], received: readonly string[]): string;
/**
 * Legacy no-schema aliasing for read/write/edit when OpenCode schemas are
 * unavailable. Maps Cursor-native snake_case (and path) onto OpenCode camelCase
 * for ALL known edit/write/read keys — not just filePath.
 */
export declare function legacyNormalizeFileToolArgs(toolName: string, args: Record<string, unknown>): Record<string, unknown>;
/** Stable sorted list of own keys (for diagnostics / telemetry). */
export declare function argKeyList(args: Record<string, unknown> | null | undefined): string[];