usecase

type InvocationDetails struct {
	// Type helps the invoker understand the nature of the call (e.g., "http", "connect_http", "grpc").
	Type string `json:"type"`

	// Host is the base URL of the target service (e.g., "http://localhost:8080" or "grpc://localhost:50051").
	Host string `json:"host"`

	// BasePath is the extracted from OpenAPI servers (e.g., "/api/v1").
	BasePath string `json:"base_path,omitempty"`

	// HTTPMethod is the HTTP verb (e.g., "POST", "GET").
	HTTPMethod string `json:"http_method,omitempty"`

	// HTTPPath is the request path (e.g., "/users/{userId}", "/com.example.UserService/GetUser").
	HTTPPath string `json:"http_path,omitempty"`

	// PathParams lists the names of parameters expected to be substituted into the HTTPPath.
	PathParams []string `json:"path_params,omitempty"`

	// QueryParams lists the names of parameters expected to be sent as URL query arguments.
	QueryParams []string `json:"query_params,omitempty"`

	// HeaderParams defines static headers to be included in the request.
	// Dynamic headers (e.g., from tool parameters) might be handled separately by the invoker.
	HeaderParams map[string]string `json:"header_params,omitempty"`

	// BodyParam indicates which single tool input parameter should be marshalled as the HTTP request body.
	// If empty, the request body might be constructed from multiple parameters or be absent.
	BodyParam string `json:"body_param,omitempty"`

	// gRPC specific fields
	// GRPCService is the full service name (e.g., "hello.HelloService")
	GRPCService string `json:"grpc_service,omitempty"`

	// GRPCMethod is the method name (e.g., "SayHello")
	GRPCMethod string `json:"grpc_method,omitempty"`

	// For .proto files: Server is the actual gRPC server endpoint
	Server string `json:"server,omitempty"`

	// For .proto files: Method is the full method path (e.g., "/package.Service/Method")
	Method string `json:"method,omitempty"`

	// For .proto files: Input and Output type names
	InputType  string `json:"input_type,omitempty"`
	OutputType string `json:"output_type,omitempty"`

	// For .proto files: File descriptor for dynamic invocation
	FileDescriptor interface{} `json:"file_descriptor,omitempty"`

	// ContentType indicates the expected Content-Type for the request body (e.g., "application/json").
	// Defaults to application/json if involving a body.
	ContentType string `json:"content_type,omitempty"`
}

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

type MCPServerAdapter interface {
	// AddTool registers a tool and its handler with the server.
	// The handlerFunc signature must match the expected signature of the specific
	// MCP server library being adapted.
	// Use the specific type from the mcp-go/server package.
	AddTool(tool mcp.Tool, handlerFunc mcpGoServer.ToolHandlerFunc)
}

type SchemaFetcher interface {
	Fetch(ctx context.Context, source string) (domain.APISchema, error)
	FetchWithConfig(ctx context.Context, config SchemaSourceConfig) (domain.APISchema, error)
}

type SchemaSourceConfig struct {
	URL     string
	Headers map[string]string
	Server  string // For .proto files, the gRPC server endpoint
	Type    string // Schema type override (e.g., "connect" for Connect-RPC)
	Mode    string // Invocation mode (e.g., "http" or "grpc" for Connect-RPC)
}

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

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

type ToolGenerator interface {
	Generate(schema domain.APISchema) ([]domain.Tool, []InvocationDetails, error)
}

type ToolInvoker interface {
	Invoke(ctx context.Context, details InvocationDetails, params map[string]interface{}) (interface{}, error)
}

type ToolRepository interface {
	// Save stores a list of tools and their associated invocation details.
	// It should ensure that the length of tools and details match and correspond by index,
	// or handle potential mismatches appropriately.
	Save(ctx context.Context, tools []domain.Tool, details []InvocationDetails) error

	// List retrieves all currently stored tools.
	List(ctx context.Context) ([]domain.Tool, error)

	// FindToolByName retrieves a specific tool definition by its unique name.
	FindToolByName(ctx context.Context, name string) (*domain.Tool, error)

	// FindInvocationDetailsByName retrieves the invocation details for a specific tool by name.
	FindInvocationDetailsByName(ctx context.Context, name string) (*InvocationDetails, error)
}