adapter

type A2AAdapter struct{}

type A2AAgentCapabilities struct {
	Streaming         *bool               `json:"streaming,omitempty"`
	PushNotifications *bool               `json:"pushNotifications,omitempty"`
	Extensions        []A2AAgentExtension `json:"extensions,omitempty"`
	ExtendedAgentCard *bool               `json:"extendedAgentCard,omitempty"`
}

type A2AAgentCard struct {
	Name                 string                    `json:"name"`
	Description          string                    `json:"description"`
	SupportedInterfaces  []A2AAgentInterface       `json:"supportedInterfaces"`
	Provider             *A2AAgentProvider         `json:"provider,omitempty"`
	Version              string                    `json:"version"`
	DocumentationURL     string                    `json:"documentationUrl,omitempty"`
	Capabilities         A2AAgentCapabilities      `json:"capabilities"`
	SecuritySchemes      map[string]SecurityScheme `json:"securitySchemes,omitempty"`
	SecurityRequirements []SecurityRequirement     `json:"securityRequirements,omitempty"`
	DefaultInputModes    []string                  `json:"defaultInputModes"`
	DefaultOutputModes   []string                  `json:"defaultOutputModes"`
	Skills               []A2AAgentSkill           `json:"skills"`
	Signatures           []map[string]any          `json:"signatures,omitempty"`
	IconURL              string                    `json:"iconUrl,omitempty"`
}

type A2AAgentExtension struct {
	URI         string         `json:"uri,omitempty"`
	Description string         `json:"description,omitempty"`
	Required    *bool          `json:"required,omitempty"`
	Params      map[string]any `json:"params,omitempty"`
}

type A2AAgentInterface struct {
	URL             string `json:"url"`
	ProtocolBinding string `json:"protocolBinding"`
	Tenant          string `json:"tenant,omitempty"`
	ProtocolVersion string `json:"protocolVersion"`
}

type A2AAgentProvider struct {
	URL          string `json:"url"`
	Organization string `json:"organization"`
}

type A2AAgentSkill struct {
	ID                   string                `json:"id"`
	Name                 string                `json:"name"`
	Description          string                `json:"description"`
	Tags                 []string              `json:"tags"`
	Examples             []string              `json:"examples,omitempty"`
	InputModes           []string              `json:"inputModes,omitempty"`
	OutputModes          []string              `json:"outputModes,omitempty"`
	SecurityRequirements []SecurityRequirement `json:"securityRequirements,omitempty"`
}

type Adapter interface {
	// Name returns the adapter's identifier (e.g., "mcp", "openai", "anthropic")
	Name() string

	// ToCanonical converts a protocol-specific tool to canonical format.
	// The raw parameter type depends on the adapter (e.g., mcp.Tool, OpenAIFunction).
	ToCanonical(raw any) (*CanonicalTool, error)

	// FromCanonical converts a canonical tool to the protocol-specific format.
	// The returned type depends on the adapter.
	FromCanonical(tool *CanonicalTool) (any, error)

	// SupportsFeature returns whether this adapter supports a schema feature.
	// Features not supported will generate warnings during conversion.
	SupportsFeature(feature SchemaFeature) bool
}

type AdapterRegistry struct {
	// contains filtered or unexported fields
}

type AnthropicAdapter struct{}

type AnthropicCacheControl struct {
	Type string `json:"type"` // "ephemeral"
}

type AnthropicTool struct {
	Name          string                 `json:"name"`
	Description   string                 `json:"description,omitempty"`
	InputSchema   map[string]any         `json:"input_schema"`
	InputExamples []any                  `json:"input_examples,omitempty"`
	CacheControl  *AnthropicCacheControl `json:"cache_control,omitempty"`
}

type CanonicalProvider struct {
	// Name is the provider name (required).
	Name string

	// Description explains what the provider does.
	Description string

	// Version is the provider version.
	Version string

	// Capabilities lists provider capabilities (e.g., streaming, push notifications).
	Capabilities map[string]any

	// SecuritySchemes defines auth schemes supported by the provider.
	SecuritySchemes map[string]SecurityScheme

	// SecurityRequirements defines required schemes/scopes to access the provider.
	SecurityRequirements []SecurityRequirement

	// DefaultInputModes lists default input media types for all tools.
	DefaultInputModes []string

	// DefaultOutputModes lists default output media types for all tools.
	DefaultOutputModes []string

	// Skills are the tools offered by the provider.
	Skills []CanonicalTool

	// SourceFormat is the original format (e.g., "a2a").
	SourceFormat string

	// SourceMeta contains format-specific metadata for round-trip conversion.
	SourceMeta map[string]any
}

type CanonicalTool struct {
	// Namespace groups related tools (e.g., "github", "slack")
	Namespace string

	// Name is the tool's identifier (required)
	Name string

	// DisplayName is a human-friendly name for UI presentation.
	DisplayName string

	// Version is the semantic version of the tool
	Version string

	// Description explains what the tool does
	Description string

	// Summary is a short description for discovery results.
	Summary string

	// Category classifies the tool's purpose
	Category string

	// Tags are keywords for discovery
	Tags []string

	// InputModes lists supported input media types (e.g., "application/json").
	InputModes []string

	// OutputModes lists supported output media types.
	OutputModes []string

	// Examples provides example prompts or usage scenarios.
	Examples []string

	// Deterministic indicates whether the tool returns deterministic results.
	Deterministic *bool

	// Idempotent indicates whether the tool is idempotent.
	Idempotent *bool

	// Streaming indicates whether the tool supports streaming output.
	Streaming *bool

	// SecuritySchemes defines auth schemes required by this tool.
	SecuritySchemes map[string]SecurityScheme

	// SecurityRequirements defines required schemes/scopes for this tool.
	SecurityRequirements []SecurityRequirement

	// Annotations contains protocol-agnostic annotations for UI or policy.
	Annotations map[string]any

	// UIHints provides UI-specific hints for rendering tool inputs.
	UIHints map[string]any

	// InputSchema defines the tool's input parameters (required)
	InputSchema *JSONSchema

	// OutputSchema defines the tool's output format
	OutputSchema *JSONSchema

	// Timeout is the maximum execution time
	Timeout time.Duration

	// SourceFormat is the original format (e.g., "mcp", "openai", "anthropic")
	SourceFormat string

	// SourceMeta contains format-specific metadata for round-trip conversion
	SourceMeta map[string]any

	// RequiredScopes are authorization scopes needed to use the tool
	RequiredScopes []string
}

type ConversionError struct {
	// Adapter is the name of the adapter that encountered the error
	Adapter string

	// Direction is "to_canonical" or "from_canonical"
	Direction string

	// Cause is the underlying error
	Cause error
}

type ConversionResult struct {
	// Tool is the converted tool in the target format
	Tool any

	// Warnings lists features that may have been lost during conversion
	Warnings []FeatureLossWarning
}

type FeatureLossWarning struct {
	// Feature is the schema feature that will be lost
	Feature SchemaFeature

	// Path is the JSON pointer path to the schema location using the feature.
	// Empty string indicates the root schema.
	Path string

	// FromAdapter is the source adapter name
	FromAdapter string

	// ToAdapter is the target adapter name
	ToAdapter string
}

type GeminiAdapter struct{}

type GeminiFunctionDeclaration struct {
	Name        string         `json:"name"`
	Description string         `json:"description,omitempty"`
	Parameters  map[string]any `json:"parameters,omitempty"`
}

type GeminiTool struct {
	FunctionDeclarations []GeminiFunctionDeclaration `json:"functionDeclarations,omitempty"`
}

type JSONSchema struct {
	// Type is the JSON type (object, array, string, number, integer, boolean, null)
	Type string

	// Title is a short schema name.
	Title string

	// Properties maps property names to their schemas (for object types)
	Properties map[string]*JSONSchema

	// Required lists property names that must be present
	Required []string

	// Items is the schema for array elements
	Items *JSONSchema

	// Description explains the schema
	Description string

	// Enum restricts values to a fixed set
	Enum []any

	// Const restricts to a single value
	Const any

	// Default is the default value
	Default any

	// Examples provide sample values.
	Examples []any

	// MultipleOf is a numeric multiple constraint.
	MultipleOf *float64

	// Minimum is the minimum numeric value
	Minimum *float64

	// Maximum is the maximum numeric value
	Maximum *float64

	// MinLength is the minimum string length
	MinLength *int

	// MaxLength is the maximum string length
	MaxLength *int

	// MinItems is the minimum array length
	MinItems *int

	// MaxItems is the maximum array length
	MaxItems *int

	// MinProperties is the minimum number of properties
	MinProperties *int

	// MaxProperties is the maximum number of properties
	MaxProperties *int

	// UniqueItems requires array items to be unique
	UniqueItems *bool

	// Pattern is a regex pattern for string validation
	Pattern string

	// Format is a semantic format (e.g., "email", "uri", "date-time")
	Format string

	// Ref is a JSON Pointer reference to another schema ($ref)
	Ref string

	// Defs contains schema definitions ($defs)
	Defs map[string]*JSONSchema

	// AdditionalProperties controls whether extra properties are allowed
	AdditionalProperties *bool

	// Nullable indicates nullable values (OpenAPI-compatible).
	Nullable *bool

	// Deprecated marks the schema as deprecated.
	Deprecated *bool

	// ReadOnly indicates read-only properties.
	ReadOnly *bool

	// WriteOnly indicates write-only properties.
	WriteOnly *bool

	// AnyOf allows any of the listed schemas
	AnyOf []*JSONSchema

	// OneOf requires exactly one of the listed schemas
	OneOf []*JSONSchema

	// AllOf requires all of the listed schemas
	AllOf []*JSONSchema

	// Not disallows the specified schema
	Not *JSONSchema
}

type MCPAdapter struct{}

type OpenAIAdapter struct{}

type OpenAIFunction struct {
	Name        string         `json:"name"`
	Description string         `json:"description,omitempty"`
	Parameters  map[string]any `json:"parameters"`
	Strict      *bool          `json:"strict,omitempty"`
}

type OpenAITool struct {
	Type     string         `json:"type"` // always "function"
	Function OpenAIFunction `json:"function"`
}

type SchemaFeature int

type SecurityRequirement map[string][]string

type SecurityScheme map[string]any